@khanacademy/simple-markdown 0.8.2 → 0.8.4

package/package.json

@@ -3,7 +3,7 @@
     "description": "Javascript markdown parsing, made simple",
     "author": "Khan Academy",
     "license": "MIT",
-    "version": "0.8.2",
+    "version": "0.8.4",
     "publishConfig": {
         "access": "public"
     },
@@ -25,7 +25,7 @@
     },
     "devDependencies": {
         "@types/react-dom": ">=16.0.0",
-        "perseus-build-settings": "^0.0.2",
+        "perseus-build-settings": "^0.0.3",
         "size-limit": "^0.21.1",
         "typescript": "^3.6.4",
         "uglify-js": "^3.6.7"

package/src/__tests__/simple-markdown_test.js

@@ -4943,4 +4943,31 @@ describe("simple markdown", function () {
             );
         });
     });
+
+    describe("custom rules", () => {
+        it("should throw if `parse` returns invalid result", () => {
+            const parse = jest
+                .fn()
+                // Flow correctly catches that the `parse` function returns and
+                // incorrect type, but I want to keep this test here for now
+                // because in call sites that use this, we've seen Flow not
+                // catch this. So for now, we hard-fail!
+                // $FlowFixMe[incompatible-call]
+                .mockImplementation(() => "invalid parse result");
+
+            const invalidRules = {
+                parseDoesntReturnCorrectType: {
+                    order: 1,
+                    match: (source, state, prevCapture) => true,
+                    parse,
+                },
+            };
+
+            expect(() =>
+                // $FlowFixMe[incompatible-call]
+                SimpleMarkdown.parserFor(invalidRules)("some input"),
+            ).toThrow();
+            expect(parse).toHaveBeenCalled();
+        });
+    });
 });

package/src/index.js

@@ -320,7 +320,10 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
     });
 
     var latestState: State;
-    var nestedParse = function (source: string, state: ?State): Parser {
+    var nestedParse: Parser = function (
+        source: string,
+        state: ?State,
+    ): Array<SingleASTNode> {
         var result: Array<SingleASTNode> = [];
         state = state || latestState;
         latestState = state;
@@ -400,7 +403,6 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
                 );
             }
 
-            // $FlowFixMe
             var parsed = rule.parse(capture, nestedParse, state);
             // We maintain the same object here so that rules can
             // store references to the objects they return and
@@ -410,6 +412,12 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
                 // $FlowFixMe
                 Array.prototype.push.apply(result, parsed);
             } else {
+                if (parsed == null || typeof parsed !== "object") {
+                    throw new Error(
+                        `parse() function returned invalid parse result: '${parsed}'`,
+                    );
+                }
+
                 // We also let rules override the default type of
                 // their parsed node if they would like to, so that
                 // there can be a single output function for all links,
@@ -429,7 +437,10 @@ var parserFor = function (rules: ParserRules, defaultState: ?State): Parser {
         return result;
     };
 
-    var outerParse = function (source: string, state: ?State): Parser {
+    var outerParse: Parser = function (
+        source: string,
+        state: ?State,
+    ): Array<SingleASTNode> {
         latestState = populateInitialState(state, defaultState);
         if (!latestState.inline && !latestState.disableAutoBlockNewlines) {
             source = source + "\n\n";