@adobe/helix-markdown-support 3.1.7 → 3.1.8

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [3.1.8](https://github.com/adobe/helix-markdown-support/compare/v3.1.7...v3.1.8) (2022-07-28)
+
+
+### Bug Fixes
+
+* matter plugin to run in micromark development mode ([#80](https://github.com/adobe/helix-markdown-support/issues/80)) ([36e69fa](https://github.com/adobe/helix-markdown-support/commit/36e69fa8328850950969597e074b7b610d40f0c9))
+
 ## [3.1.7](https://github.com/adobe/helix-markdown-support/compare/v3.1.6...v3.1.7) (2022-07-09)
 
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@adobe/helix-markdown-support",
-  "version": "3.1.7",
+  "version": "3.1.8",
   "description": "Helix Markdown Support",
   "type": "module",
   "scripts": {
-    "test": " c8 mocha",
+    "test": "c8 mocha",
     "test-ci": "c8 mocha && codecov",
     "lint": "eslint .",
     "semantic-release": "semantic-release",
@@ -25,6 +25,8 @@
     "hast-util-to-html": "8.0.3",
     "js-yaml": "4.1.0",
     "mdast-util-to-hast": "12.1.2",
+    "micromark-util-character": "1.1.0",
+    "micromark-util-symbol": "1.0.1",
     "unist-util-find": "1.0.2",
     "unist-util-visit": "4.1.0"
   },
@@ -32,7 +34,8 @@
     "spec": "test/**/*.test.js",
     "recursive": "true",
     "reporter": "mocha-multi-reporters",
-    "reporter-options": "configFile=.mocha-multi.json"
+    "reporter-options": "configFile=.mocha-multi.json",
+    "node-option": "conditions=development"
   },
   "peerDependencies": {
     "unified": "10.x"
@@ -41,13 +44,13 @@
     "@adobe/eslint-config-helix": "1.3.2",
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/git": "10.0.1",
-    "c8": "7.11.3",
+    "c8": "7.12.0",
     "codecov": "3.8.3",
-    "eslint": "8.19.0",
+    "eslint": "8.20.0",
     "eslint-plugin-header": "3.1.1",
     "eslint-plugin-import": "2.26.0",
     "husky": "8.0.1",
-    "junit-report-builder": "3.0.0",
+    "junit-report-builder": "3.0.1",
     "lint-staged": "13.0.3",
     "mdast-builder": "1.1.1",
     "mocha": "10.0.0",
@@ -57,7 +60,7 @@
     "remark-stringify": "10.0.2",
     "semantic-release": "19.0.3",
     "unified": "10.1.2",
-    "unist-util-inspect": "7.0.0"
+    "unist-util-inspect": "7.0.1"
   },
   "lint-staged": {
     "*.js": "eslint"

package/src/remark-matter/syntax.js

@@ -11,11 +11,12 @@
  */
 /* eslint-disable no-use-before-define */
 import jsYaml from 'js-yaml';
+import { codes } from 'micromark-util-symbol/codes.js';
+import { types } from 'micromark-util-symbol/types.js';
+import { markdownLineEnding, markdownSpace } from 'micromark-util-character';
 
 const type = (v) => ((v !== undefined && v !== null) ? v.constructor : v);
 
-const CODE_DASH = '-'.charCodeAt(0);
-
 function validYaml(str, errorHandler) {
   // console.log('validate yaml', str);
   try {
@@ -49,9 +50,9 @@ function validYaml(str, errorHandler) {
 }
 
 function parse(options) {
-  const valueType = 'yamlValue';
-  const fenceType = 'yamlFence';
-  const sequenceType = 'yamlSequence';
+  const yamlValue = 'yamlValue';
+  const yamlFence = 'yamlFence';
+  const yamlSequence = 'yamlSequence';
   const { errorHandler } = options;
 
   const fenceConstruct = {
@@ -102,20 +103,20 @@ function parse(options) {
     function lineStart(code) {
       // set the whitespace flag to true
       wasWS = true;
-      if (code === -5 || code === -4 || code === -3 || code === null) {
+      if (code === codes.eof || markdownLineEnding(code)) {
         return lineEnd(code);
       }
-      effects.enter(valueType);
+      effects.enter(yamlValue);
       return lineData(code);
     }
 
     function lineData(code) {
-      if (code === -5 || code === -4 || code === -3 || code === null) {
-        effects.exit(valueType);
+      if (code === codes.eof || markdownLineEnding(code)) {
+        effects.exit(yamlValue);
         return lineEnd(code);
       }
 
-      if (!(code === -2 || code === -1 || code === 32)) {
+      if (!markdownSpace(code)) {
         // if not whitespace, clear flag
         wasWS = false;
       }
@@ -125,40 +126,7 @@ function parse(options) {
     }
 
     function closedFence(code) {
-      // if we are at the end, don't check for empty line after
-      if (code === null) {
-        return afterClosedFence(code);
-      }
-
-      // remember new line
-      effects.enter('lineEnding');
-      effects.consume(code);
-      effects.exit('lineEnding');
-
-      // this is a bit a hack to avoid create soo many states
-      wasWS = false;
-
-      return afterClosedFence;
-    }
-
-    function afterClosedFence(code) {
-      // check for whitespace
-      if (code === -2 || code === -1 || code === 32) {
-        if (!wasWS) {
-          effects.enter('whitespace');
-          wasWS = true;
-        }
-        effects.consume(code);
-        return afterClosedFence;
-      } else if (wasWS) {
-        effects.exit('whitespace');
-        wasWS = false;
-      }
-
-      if (code !== -5 && code !== -4 && code !== -3 && code !== null) {
-        return nok(code);
-      }
-
+      // check if valid yaml
       const token = effects.exit('yaml');
       let yamlString = self.sliceSerialize(token).trim();
       // remove fences
@@ -167,18 +135,20 @@ function parse(options) {
         return nok(code);
       }
 
-      if (code !== null) {
-        // since there is a blank line after the `---`, also mark it.
-        effects.enter('lineEndingBlank');
-        effects.exit('lineEndingBlank');
+      // if we are at the end, don't check for empty line after
+      if (code === codes.eof) {
+        return ok(code);
       }
 
-      return ok(code);
+      return effects.check({
+        tokenize: tokenizeEmptyLine,
+        partial: true,
+      }, ok, nok)(code);
     }
 
     function lineEnd(code) {
       // Require a closing fence.
-      if (code === null) {
+      if (code === codes.eof) {
         return nok(code);
       }
 
@@ -196,9 +166,9 @@ function parse(options) {
       }
 
       // Can only be an eol.
-      effects.enter('lineEnding');
+      effects.enter(types.lineEnding);
       effects.consume(code);
-      effects.exit('lineEnding');
+      effects.exit(types.lineEnding);
 
       // attempt to detect the closing fence `---`. if not, start next line
       return effects.attempt(fenceConstruct, closedFence, lineStart);
@@ -211,9 +181,9 @@ function parse(options) {
     return start;
 
     function start(code) {
-      if (code === CODE_DASH) {
-        effects.enter(fenceType);
-        effects.enter(sequenceType);
+      if (code === codes.dash) {
+        effects.enter(yamlFence);
+        effects.enter(yamlSequence);
         return insideSequence(code);
       }
 
@@ -222,17 +192,17 @@ function parse(options) {
 
     function insideSequence(code) {
       if (numDashes === 3) {
-        effects.exit(sequenceType);
+        effects.exit(yamlSequence);
 
-        if (code === -2 || code === -1 || code === 32) {
-          effects.enter('whitespace');
+        if (markdownSpace(code)) {
+          effects.enter(types.whitespace);
           return insideWhitespace(code);
         }
 
         return fenceEnd(code);
       }
 
-      if (code === CODE_DASH) {
+      if (code === codes.dash) {
         effects.consume(code);
         numDashes += 1;
         return insideSequence;
@@ -243,30 +213,66 @@ function parse(options) {
 
     // white space after fence
     function insideWhitespace(code) {
-      if (code === -2 || code === -1 || code === 32) {
+      if (markdownSpace(code)) {
         effects.consume(code);
         return insideWhitespace;
       }
 
-      effects.exit('whitespace');
+      effects.exit(types.whitespace);
       return fenceEnd(code);
     }
 
     // after fence (plus potential ws) we expect a LF
     function fenceEnd(code) {
-      if (code === -5 || code === -4 || code === -3 || code === null) {
-        effects.exit(fenceType);
+      if (code === codes.eof || markdownLineEnding(code)) {
+        effects.exit(yamlFence);
         return ok(code);
       }
       return nok(code);
     }
   }
+
+  function tokenizeEmptyLine(effects, ok, nok) {
+    let wasWS = false;
+
+    return start;
+
+    /**
+     * after the closed fence, we either need EOF or an empty line.
+     */
+    function start(code) {
+      // always eol
+      effects.enter(types.lineEnding);
+      effects.consume(code);
+      effects.exit(types.lineEnding);
+      return emptyLines;
+    }
+
+    function emptyLines(code) {
+      if (code === codes.eof || markdownLineEnding(code)) {
+        return ok(code);
+      }
+      // check for whitespace
+      if (markdownSpace(code)) {
+        if (!wasWS) {
+          effects.enter(types.whitespace);
+          wasWS = true;
+        }
+        effects.consume(code);
+        return emptyLines;
+      }
+      if (wasWS) {
+        effects.exit(types.whitespace);
+      }
+      return nok(code);
+    }
+  }
 }
 
 export default function create(options = {}) {
   return {
     flow: {
-      [CODE_DASH]: [parse(options)],
+      [codes.dash]: [parse(options)],
     },
   };
 }