@khanacademy/simple-markdown 0.8.5 → 0.9.0

package/package.json

@@ -3,7 +3,7 @@
     "description": "Javascript markdown parsing, made simple",
     "author": "Khan Academy",
     "license": "MIT",
-    "version": "0.8.5",
+    "version": "0.9.0",
     "publishConfig": {
         "access": "public"
     },
@@ -16,7 +16,7 @@
     },
     "module": "dist/es/index.js",
     "main": "dist/index.js",
-    "source": "src/index.js",
+    "source": "src/index.ts",
     "scripts": {
         "test": "bash -c 'yarn --silent --cwd \"../..\" test ${@:0} $($([[ ${@: -1} = -* ]] || [[ ${@: -1} = bash ]]) && echo $PWD)'"
     },
@@ -25,7 +25,7 @@
     },
     "devDependencies": {
         "@types/react-dom": ">=16.0.0",
-        "perseus-build-settings": "^0.0.4",
+        "perseus-build-settings": "^0.0.5",
         "size-limit": "^0.21.1",
         "typescript": "^3.6.4",
         "uglify-js": "^3.6.7"

package/src/__tests__/{simple-markdown_test.js → simple-markdown.test.ts}

@@ -1,17 +1,12 @@
-/* eslint-disable no-var, no-unused-vars, no-console, import/no-commonjs, no-redeclare, no-useless-escape */
-// @flow
-/* @ts-check */
-import {render} from "@testing-library/react";
+/* eslint-disable no-var, @typescript-eslint/no-unused-vars, no-console, import/no-commonjs, no-redeclare, no-useless-escape */
+import assert from "assert";
 
-// As of 2019-11-03, flow doesn't have definitions for assert.strict:
-// https://github.com/facebook/flow/pull/7660
-// So we use a /*::*/ hack to satisfy flow:
-import SimpleMarkdown from "../index.js";
+import * as React from "react";
+import * as ReactDOMServer from "react-dom/server";
 
-var assert = require("assert") /*:: || {} */.strict;
+import SimpleMarkdown from "../index";
 
-var React = require("react");
-var ReactDOMServer = require("react-dom/server");
+import type {SingleASTNode} from "../index";
 
 var inlineParse = SimpleMarkdown.defaultInlineParse;
 var blockParse = SimpleMarkdown.defaultBlockParse;
@@ -39,7 +34,7 @@ var FLOW_IGNORE_COVARIANCE = {
  *
  * @param {SimpleMarkdown.ASTNode | Array<SimpleMarkdown.TableAlignment>} ast
  */
-var prettyPrintAST = function (ast) {
+var prettyPrintAST = function (ast: any) {
     return JSON.stringify(ast, null, 4);
     //    // FIXME(aria): For debugging in more depth? This used to work?
     //    return nodeUtil.inspect(ast, {
@@ -77,7 +72,7 @@ var reactToHtml = function (reactElements) {
  * @param {SimpleMarkdown.ASTNode} parsed
  * @returns {string}
  */
-var htmlThroughReact = function (parsed) {
+var htmlThroughReact = function (parsed: Array<SingleASTNode>) {
     var output = defaultReactOutput(parsed);
     return reactToHtml(output);
 };
@@ -104,7 +99,7 @@ var htmlFromMarkdown = function (source) {
  * @param {string} source
  * @param {string} html
  */
-var assertParsesToReact = function (source, html) {
+var assertParsesToReact = function (source: string, html: string) {
     var actualHtml = htmlFromReactMarkdown(source);
     assert.strictEqual(actualHtml, html);
 };
@@ -113,7 +108,7 @@ var assertParsesToReact = function (source, html) {
  * @param {string} source
  * @param {string} html
  */
-var assertParsesToHtml = function (source, html) {
+var assertParsesToHtml = function (source: string, html) {
     var actualHtml = htmlFromMarkdown(source);
     assert.strictEqual(actualHtml, html);
 };
@@ -3066,11 +3061,11 @@ describe("simple markdown", function () {
                         [{type: "text", content: "h2"}],
                         [{type: "text", content: "h3"}],
                     ],
-                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ ([
+                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ [
                         null,
                         null,
                         null,
-                    ]),
+                    ],
                     cells: [
                         [
                             [{type: "text", content: "d1"}],
@@ -3129,11 +3124,11 @@ describe("simple markdown", function () {
                             },
                         ],
                     ],
-                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ ([
+                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ [
                         null,
                         null,
                         null,
-                    ]),
+                    ],
                     cells: [
                         [
                             [
@@ -3181,7 +3176,10 @@ describe("simple markdown", function () {
              * @param {string} tableSrc
              * @param {Array<SimpleMarkdown.TableAlignment>} expectedAligns
              */
-            var validateAligns = function (tableSrc, expectedAligns) {
+            var validateAligns = function (
+                tableSrc,
+                expectedAligns: Array<null> | Array<string>,
+            ) {
                 var parsed = blockParse(tableSrc + "\n");
                 assert.strictEqual(parsed[0].type, "table");
                 var actualAligns = parsed[0].align;
@@ -3192,11 +3190,11 @@ describe("simple markdown", function () {
                 "| h1 | h2 | h3 |\n" +
                     "| -- | -- | -- |\n" +
                     "| d1 | d2 | d3 |\n",
-                /** @type {Array<SimpleMarkdown.TableAlignment>} */ ([
+                /** @type {Array<SimpleMarkdown.TableAlignment>} */ [
                     null,
                     null,
                     null,
-                ]),
+                ],
             );
 
             validateAligns(
@@ -3235,16 +3233,16 @@ describe("simple markdown", function () {
             var expected = [
                 {
                     type: "table",
-                    header: /** @type {any[][]} */ ([[], [], []]),
-                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ ([
+                    header: /** @type {any[][]} */ [[], [], []],
+                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ [
                         null,
                         null,
                         null,
-                    ]),
-                    cells: /** @type {any[][]} */ ([
+                    ],
+                    cells: /** @type {any[][]} */ [
                         [[], [], []],
                         [[], [], []],
-                    ]),
+                    ],
                 },
             ];
 
@@ -3283,10 +3281,10 @@ describe("simple markdown", function () {
                             {type: "text", content: "|"},
                         ],
                     ],
-                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ ([
+                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ [
                         null,
                         null,
-                    ]),
+                    ],
                     cells: [
                         [
                             [
@@ -3332,10 +3330,10 @@ describe("simple markdown", function () {
                         [{type: "text", content: "Attribute"}],
                         [{type: "text", content: "Type"}],
                     ],
-                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ ([
+                    align: /** @type {Array<SimpleMarkdown.TableAlignment>} */ [
                         null,
                         null,
-                    ]),
+                    ],
                     cells: [
                         [
                             [{type: "inlineCode", content: "position"}],
@@ -3485,11 +3483,11 @@ describe("simple markdown", function () {
                 percentVar: percentVarRule,
             });
 
-            // $FlowFixMe
+            // @ts-expect-error [FEI-5003] - TS2345 - Argument of type 'DefaultRules & { percentVar: { match: (source: any) => RegExpExecArray | null; order: number; parse: (capture: any, parse: any, state: any) => { content: any; }; }; }' is not assignable to parameter of type 'ParserRules'.
             var rawBuiltParser = SimpleMarkdown.parserFor(rules);
 
             /** @type {SimpleMarkdown.Parser} */
-            var inlineParse = function (source) {
+            var inlineParse = function (source: string) {
                 return rawBuiltParser(source, {inline: true});
             };
 
@@ -3532,7 +3530,6 @@ describe("simple markdown", function () {
             });
 
             it("should sort rules by order", function () {
-                // $FlowFixMe
                 var parser1 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 0,
@@ -3546,7 +3543,6 @@ describe("simple markdown", function () {
                 var parsed1 = parser1("_hi_", {inline: true});
                 validateParse(parsed1, [{content: "hi", type: "em1"}]);
 
-                // $FlowFixMe
                 var parser2 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 1,
@@ -3562,7 +3558,6 @@ describe("simple markdown", function () {
             });
 
             it("should allow fractional orders", function () {
-                // $FlowFixMe
                 var parser1 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 1.4,
@@ -3576,7 +3571,6 @@ describe("simple markdown", function () {
                 var parsed1 = parser1("_hi_", {inline: true});
                 validateParse(parsed1, [{content: "hi", type: "em2"}]);
 
-                // $FlowFixMe
                 var parser2 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 0.5,
@@ -3592,7 +3586,6 @@ describe("simple markdown", function () {
             });
 
             it("should allow negative orders", function () {
-                // $FlowFixMe
                 var parser1 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 0,
@@ -3606,7 +3599,6 @@ describe("simple markdown", function () {
                 var parsed1 = parser1("_hi_", {inline: true});
                 validateParse(parsed1, [{content: "hi", type: "em2"}]);
 
-                // $FlowFixMe
                 var parser2 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: -2,
@@ -3622,7 +3614,6 @@ describe("simple markdown", function () {
             });
 
             it("should break ties by rule name", function () {
-                // $FlowFixMe
                 var parser1 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 0,
@@ -3638,7 +3629,6 @@ describe("simple markdown", function () {
 
                 // ...regardless of their order in the
                 // original rule definition
-                // $FlowFixMe
                 var parser2 = SimpleMarkdown.parserFor({
                     em2: Object.assign({}, emRule, {
                         order: 0,
@@ -3658,12 +3648,12 @@ describe("simple markdown", function () {
                 /** @type {any[]} */
                 var warnings = [];
                 /*::FLOW_IGNORE_COVARIANCE.*/ console.warn = function (
-                    /** @type {any} */ warning,
+                    /** @type {any} */ warning: any,
                 ) {
+                    // @ts-expect-error [FEI-5003] - TS2345 - Argument of type 'any' is not assignable to parameter of type 'never'.
                     warnings.push(warning);
                 };
 
-                // $FlowFixMe
                 var parser1 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 1 / 0 - 1 / 0,
@@ -3681,7 +3671,6 @@ describe("simple markdown", function () {
             });
 
             it("should break ties with quality", function () {
-                // $FlowFixMe
                 var parser1 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 0,
@@ -3704,7 +3693,6 @@ describe("simple markdown", function () {
                 // ...regardless of their order in the
                 // original rule definition
 
-                // $FlowFixMe
                 var parser2 = SimpleMarkdown.parserFor({
                     em2: Object.assign({}, emRule, {
                         order: 0,
@@ -3726,7 +3714,6 @@ describe("simple markdown", function () {
             });
 
             it("rules with quality should always win the tie", function () {
-                // $FlowFixMe
                 var parser1 = SimpleMarkdown.parserFor({
                     em1: Object.assign({}, emRule, {
                         order: 0,
@@ -3745,7 +3732,6 @@ describe("simple markdown", function () {
 
                 // except if they don't match
 
-                // $FlowFixMe
                 var parser2 = SimpleMarkdown.parserFor({
                     em: Object.assign({}, emRule, {
                         order: 0,
@@ -3857,7 +3843,7 @@ describe("simple markdown", function () {
                 }),
             };
 
-            // $FlowFixMe
+            // @ts-expect-error [FEI-5003] - TS2345 - Argument of type '{ Array: { result: (arr: any, output: any, state: any) => any; }; word: { order: number; match: (source: any) => RegExpExecArray | null; parse: (capture: any, parse: any, state: any) => { ...; }; result: (node: any, output: any, state: any) => any; }; delimiter: SingleNodeParserRule & ... 2 more ... & { ...; }; }' is not assignable to parameter of type 'ParserRules'.
             var parse = SimpleMarkdown.parserFor(rules, {wordCount: 0});
             var output = SimpleMarkdown.outputFor(rules, "result", {
                 wordCount: 0,
@@ -3865,7 +3851,7 @@ describe("simple markdown", function () {
 
             // test parsing
             /** @type {{ wordCount?: number }} */
-            var parseState = {};
+            var parseState: Record<string, any> = {};
             var ast1 = parse("hi here are some words", parseState);
             assert.strictEqual(parseState.wordCount, 5);
             // and repeated parsing
@@ -3875,7 +3861,7 @@ describe("simple markdown", function () {
 
             // test output
             /** @type {{ wordCount?: number }} */
-            var outputState = {};
+            var outputState: Record<string, any> = {};
             var result1 = output(ast1, outputState);
             assert.deepEqual(result1, ["hi", "here", "are", "some", "words"]);
             assert.strictEqual(outputState.wordCount, 5);
@@ -4132,7 +4118,7 @@ describe("simple markdown", function () {
                 text: SimpleMarkdown.defaultRules.text,
             };
 
-            // $FlowFixMe
+            // @ts-expect-error [FEI-5003] - TS2345 - Argument of type '{ Array: { readonly react: ArrayNodeOutput<ReactNode>; readonly html: ArrayNodeOutput<string>; }; spoiler: { order: number; match: (source: any) => RegExpExecArray | null; parse: (capture: any, parse: any) => { ...; }; html: (node: any, output: any) => string; }; text: TextInOutRule; }' is not assignable to parameter of type 'ParserRules'.
             var parse = SimpleMarkdown.parserFor(rules, {inline: true});
             var output = SimpleMarkdown.outputFor(rules, "html");
 
@@ -4475,7 +4461,6 @@ describe("simple markdown", function () {
                 }),
             });
 
-            // $FlowFixMe[incompatible-call]
             var output = SimpleMarkdown.outputFor(rules, "react");
 
             var parsed = SimpleMarkdown.defaultInlineParse("Hi! You! Are! <3!");
@@ -4961,10 +4946,11 @@ describe("simple markdown", function () {
                     match: (source, state, prevCapture) => true,
                     parse,
                 },
-            };
+            } as const;
 
             expect(() =>
                 // $FlowFixMe[incompatible-call]
+                // @ts-expect-error [FEI-5003] - TS2345 - Argument of type '{ readonly parseDoesntReturnCorrectType: { readonly order: 1; readonly match: (source: any, state: any, prevCapture: any) => boolean; readonly parse: Mock<any, any, any>; }; }' is not assignable to parameter of type 'ParserRules'.
                 SimpleMarkdown.parserFor(invalidRules)("some input"),
             ).toThrow();
             expect(parse).toHaveBeenCalled();