@markedjs/testutils 9.0.3

package/.eslintrc.cjs

@@ -0,0 +1,11 @@
+module.exports = {
+  env: {
+    node: true,
+    es2021: true,
+  },
+  extends: "eslint:recommended",
+  parserOptions: {
+    ecmaVersion: "latest",
+    sourceType: "module",
+  },
+};

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "npm"
+    versioning-strategy: "increase"
+    directory: "/"
+    schedule:
+      interval: "weekly"

package/.github/workflows/automerge.yml

@@ -0,0 +1,42 @@
+name: "Automerge"
+on:
+  workflow_run:
+    workflows:
+      - CI
+    types:
+      - completed
+
+jobs:
+  Automerge:
+    runs-on: ubuntu-latest
+    if: |
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion == 'success'
+    steps:
+      - name: "Merge PR"
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const pr = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.payload.workflow_run.pull_requests[0].number,
+            });
+            if (!pr.data.title.includes('marked')) {
+              console.log('Not Merged 🚫');
+              console.log(`Must update marked-repo as well`);
+            } else if (!pr.data.title.startsWith('chore(deps-dev):')) {
+              console.log('Not Merged 🚫');
+              console.log(`Title '${pr.data.title}' does not start with 'chore(deps-dev):'`);
+            } else if (pr.data.user.login !== 'dependabot[bot]') {
+              console.log('Not Merged 🚫');
+              console.log(`User '${pr.data.user.login}' does not equal 'dependabot[bot]'`);
+            } else {
+              await github.rest.pulls.merge({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                pull_number: context.payload.workflow_run.pull_requests[0].number,
+              });
+              console.log('Merged 🎉');
+            }

package/.github/workflows/tests.yml

@@ -0,0 +1,78 @@
+name: "Tests"
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  Test:
+    strategy:
+      matrix:
+        node_version: ["lts/*", "*"]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node_version }}
+          check-latest: true
+      - name: Install Dependencies
+        run: npm ci
+      - name: Test 👩🏽‍💻
+        run: npm run test
+
+  Lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "lts/*"
+      - name: Install Dependencies
+        run: npm ci
+      - name: Lint ✨
+        run: npm run test:lint
+
+  Format:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "lts/*"
+      - name: Install Dependencies
+        run: npm ci
+      - name: Format 💖
+        run: npm run test:format
+
+  Release:
+    # This will only work if the version in package.json is updated
+    needs: [Test, Lint, Format]
+    if: |
+      github.ref == 'refs/heads/main' &&
+      github.event.repository.fork == false
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: "lts/*"
+          registry-url: https://registry.npmjs.org/
+      - name: Install Dependencies
+        run: npm ci
+      - name: Publish 📝
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Marked
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @markedjs/testutils
+
+Test utilities for marked and marked extensions

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@markedjs/testutils",
+  "version": "9.0.3",
+  "description": "Test utilities for marked and marked extensions",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "node --test",
+    "test:lint": "eslint .",
+    "test:format": "prettier . --check",
+    "lint": "eslint . --fix",
+    "format": "prettier . --write"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markedjs/testutils.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/markedjs/testutils/issues"
+  },
+  "homepage": "https://github.com/markedjs/testutils#readme",
+  "dependencies": {
+    "@markedjs/html-differ": "^4.0.2",
+    "front-matter": "^4.0.2",
+    "marked": "^9.0.3",
+    "marked-repo": "https://github.com/markedjs/marked/tarball/v9.0.3"
+  },
+  "devDependencies": {
+    "eslint": "^8.50.0",
+    "prettier": "^3.0.3"
+  }
+}

package/src/get-tests.js

@@ -0,0 +1,33 @@
+import { loadTests } from "./load-tests.js";
+import { resolvePath } from "./helpers.js";
+
+export async function getTests(dirs) {
+  if (typeof dirs === "string") {
+    return await loadTests(dirs);
+  }
+
+  if (Array.isArray(dirs)) {
+    return await Promise.all(dirs.map((dir) => loadTests(dir)));
+  }
+
+  const keys = Object.keys(dirs);
+  const tests = await Promise.all(keys.map((key) => loadTests(dirs[key])));
+  const testsObj = {};
+  for (let i = 0; i < keys.length; i++) {
+    testsObj[keys[i]] = tests[i];
+  }
+
+  return testsObj;
+}
+
+export async function getAllMarkedSpecTests() {
+  return await getTests({
+    CommonMark: resolvePath(
+      "../node_modules/marked-repo/test/specs/commonmark",
+    ),
+    GFM: resolvePath("../node_modules/marked-repo/test/specs/gfm"),
+    New: resolvePath("../node_modules/marked-repo/test/specs/new"),
+    Original: resolvePath("../node_modules/marked-repo/test/specs/original"),
+    RedDOS: resolvePath("../node_modules/marked-repo/test/specs/redos"),
+  });
+}

package/src/helpers.js

@@ -0,0 +1,8 @@
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function resolvePath(p) {
+  return resolve(__dirname, p);
+}

package/src/html-differ.js

@@ -0,0 +1,48 @@
+import { HtmlDiffer } from "@markedjs/html-differ";
+
+const htmlDiffer = new HtmlDiffer({
+  ignoreSelfClosingSlash: true,
+  ignoreComments: false,
+});
+
+export const htmlIsEqual = htmlDiffer.isEqual.bind(htmlDiffer);
+export async function firstDiff(actual, expected, padding) {
+  padding = padding || 30;
+  const diffHtml = await htmlDiffer.diffHtml(actual, expected);
+  const result = diffHtml.reduce(
+    (obj, diff) => {
+      if (diff.added) {
+        if (obj.firstIndex === null) {
+          obj.firstIndex = obj.expected.length;
+        }
+        obj.expected += diff.value;
+      } else if (diff.removed) {
+        if (obj.firstIndex === null) {
+          obj.firstIndex = obj.actual.length;
+        }
+        obj.actual += diff.value;
+      } else {
+        obj.actual += diff.value;
+        obj.expected += diff.value;
+      }
+
+      return obj;
+    },
+    {
+      firstIndex: null,
+      actual: "",
+      expected: "",
+    },
+  );
+
+  return {
+    actual: result.actual.substring(
+      result.firstIndex - padding,
+      result.firstIndex + padding,
+    ),
+    expected: result.expected.substring(
+      result.firstIndex - padding,
+      result.firstIndex + padding,
+    ),
+  };
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export * from "./get-tests.js";
+export * from "./html-differ.js";
+export * from "./output-table.js";
+export * from "./run-tests.js";

package/src/load-tests.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import fm from "front-matter";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+export async function loadTests(fileOrDir) {
+  const isFile = fs.statSync(fileOrDir).isFile();
+  const files = isFile ? [path.basename(fileOrDir)] : fs.readdirSync(fileOrDir);
+  const dir = isFile ? path.dirname(fileOrDir) : fileOrDir;
+
+  const obj = {};
+
+  for (const file of files) {
+    const ext = path.extname(file);
+    const name = path.basename(file, ext);
+    const absFile = path.join(dir, file);
+    let specs = [];
+
+    switch (ext) {
+      case ".md": {
+        const content = fm(fs.readFileSync(absFile, "utf8"));
+        const skip = content.attributes.skip;
+        delete content.attributes.skip;
+        const only = content.attributes.only;
+        delete content.attributes.only;
+        specs.push({
+          section: name,
+          markdown: content.body,
+          html: fs.readFileSync(absFile.replace(/[^.]+$/, "html"), "utf8"),
+          options: content.attributes,
+          only,
+          skip,
+        });
+        break;
+      }
+      case ".js":
+      case ".mjs":
+      case ".cjs":
+      case ".json": {
+        let json;
+        try {
+          // try require first
+          json = await require(absFile);
+        } catch (err) {
+          if (err.code !== "ERR_REQUIRE_ESM") {
+            throw err;
+          }
+          // must import esm
+          json = await import(absFile);
+        }
+        specs = specs.concat(json);
+        break;
+      }
+      default:
+      // do nothing
+    }
+
+    for (let i = 0; i < specs.length; i++) {
+      const spec = specs[i];
+      if (!spec.section) {
+        spec.section = `${name}[${i}]`;
+      }
+
+      if (!obj[spec.section]) {
+        obj[spec.section] = {
+          total: 0,
+          pass: 0,
+          specs: [],
+        };
+      }
+
+      obj[spec.section].total++;
+      obj[spec.section].pass += spec.shouldFail ? 0 : 1;
+      obj[spec.section].specs.push(spec);
+    }
+  }
+
+  return obj;
+}

package/src/output-table.js

@@ -0,0 +1,34 @@
+export function outputCompletionTable(title, tests) {
+  let longestName = 0;
+  let maxTests = 0;
+
+  for (const section in tests) {
+    longestName = Math.max(section.length, longestName);
+    maxTests = Math.max(tests[section].total, maxTests);
+  }
+
+  const maxTestsLen = ("" + maxTests).length;
+  const spaces = maxTestsLen * 2 + longestName + 11;
+
+  console.log("-".padEnd(spaces + 4, "-"));
+  console.log(
+    `| ${title
+      .padStart(Math.ceil((spaces + title.length) / 2))
+      .padEnd(spaces)} |`,
+  );
+  console.log(`| ${" ".padEnd(spaces)} |`);
+  for (const section in tests) {
+    console.log(
+      `| ${section.padEnd(longestName)} ${("" + tests[section].pass).padStart(
+        maxTestsLen,
+      )} of ${("" + tests[section].total).padStart(maxTestsLen)} ${(
+        (100 * tests[section].pass) /
+        tests[section].total
+      )
+        .toFixed()
+        .padStart(4)}% |`,
+    );
+  }
+  console.log("-".padEnd(spaces + 4, "-"));
+  console.log();
+}

package/src/run-tests.js

@@ -0,0 +1,123 @@
+import { htmlIsEqual, firstDiff } from "./html-differ.js";
+import { getTests, getAllMarkedSpecTests } from "./get-tests.js";
+import nodeTest from "node:test";
+import assert from "node:assert";
+import { Marked } from "marked";
+import { outputCompletionTable } from "./output-table.js";
+
+export async function runTests({
+  tests = {},
+  defaultMarkedOptions = {},
+  parse = parseMarked,
+  addExtension = () => {},
+  isEqual = htmlIsEqual,
+  diff = firstDiff,
+} = {}) {
+  if (typeof tests === "string") {
+    tests = getTests(tests);
+  }
+
+  for (const section of Object.keys(tests)) {
+    await nodeTest(section, async (t) => {
+      for (const test of tests[section].specs) {
+        const options = {
+          ...defaultMarkedOptions,
+          ...(test.options || {}),
+        };
+        const example = test.example ? " example " + test.example : "";
+        const passFail = test.shouldFail ? "fail" : "pass";
+
+        if (typeof options.silent === "undefined") {
+          options.silent = true;
+        }
+
+        await t.test(
+          `${section} should ${passFail}${example}`,
+          {
+            only: test.only,
+            skip: test.skip,
+          },
+          async () => {
+            const before = process.hrtime();
+            let parsed = parse(test.markdown, options, addExtension);
+            if (options.async) {
+              parsed = await parsed;
+            }
+            const elapsed = process.hrtime(before);
+            const pass = await isEqual(parsed, test.html);
+            if (test.shouldFail) {
+              assert.ok(
+                !pass,
+                `${test.markdown}\n------\n\nExpected: Should Fail`,
+              );
+            } else if (options.renderExact) {
+              assert.strictEqual(test.html, parsed);
+            } else {
+              const testDiff = await diff(parsed, test.html);
+              assert(
+                pass,
+                `Expected: ${testDiff.expected}\n  Actual: ${testDiff.actual}`,
+              );
+            }
+
+            if (!options.async && elapsed[0] > 0) {
+              const s = (elapsed[0] + elapsed[1] * 1e-9).toFixed(3);
+              assert.fail(`took too long: ${s}s`);
+            }
+          },
+        );
+      }
+    });
+  }
+}
+
+export async function runAllMarkedSpecTests({
+  addExtension = () => {},
+  outputCompletionTables = true,
+} = {}) {
+  const specTests = await getAllMarkedSpecTests();
+
+  await Promise.all(
+    Object.keys(specTests).map((title) => {
+      const tests = specTests[title];
+      switch (title) {
+        case "CommonMark":
+          if (outputCompletionTables) {
+            outputCompletionTable(title, tests);
+          }
+          return runTests({
+            tests,
+            defaultMarkedOptions: { gfm: false, pedantic: false },
+            addExtension,
+          });
+        case "GFM":
+          if (outputCompletionTables) {
+            outputCompletionTable(title, tests);
+          }
+          return runTests({
+            tests,
+            defaultMarkedOptions: { gfm: true, pedantic: false },
+            addExtension,
+          });
+        case "New":
+          return runTests({ tests, addExtension });
+        case "Original":
+          return runTests({
+            tests,
+            defaultMarkedOptions: { gfm: false, pedantic: true },
+            addExtension,
+          });
+        case "RedDOS":
+          return runTests({ tests, addExtension });
+        default:
+          throw new Error("invalid title");
+      }
+    }),
+  );
+}
+
+function parseMarked(markedown, options, addExtension) {
+  const marked = new Marked(options);
+  addExtension(marked);
+  return marked.parse(markedown);
+}

package/test/get-tests.test.js

@@ -0,0 +1,30 @@
+import { getTests } from "../src/index.js";
+import { resolvePath } from "../src/helpers.js";
+import test from "node:test";
+import assert from "node:assert";
+
+test("get-tests", async (t) => {
+  await t.test("getTests(string)", async () => {
+    const tests = await getTests(
+      resolvePath("../node_modules/marked-repo/test/specs/commonmark"),
+    );
+
+    assert.ok(tests.Tabs);
+  });
+
+  await t.test("getTests(array)", async () => {
+    const tests = await getTests([
+      resolvePath("../node_modules/marked-repo/test/specs/commonmark"),
+    ]);
+
+    assert.ok(tests[0].Tabs);
+  });
+
+  await t.test("getTests(obj)", async () => {
+    const tests = await getTests({
+      test: resolvePath("../node_modules/marked-repo/test/specs/commonmark"),
+    });
+
+    assert.ok(tests.test.Tabs);
+  });
+});

package/test/html-differ.test.js

@@ -0,0 +1,31 @@
+import { htmlIsEqual, firstDiff } from "../src/index.js";
+import test from "node:test";
+import assert from "node:assert";
+
+test("html-differ", async (t) => {
+  await t.test("htmlIsEqual is equal", async () => {
+    const same = await htmlIsEqual("<p> test </p>", "<p>  test  </p>");
+
+    assert.ok(same);
+  });
+
+  await t.test("htmlIsEqual is not equal", async () => {
+    const same = await htmlIsEqual("<p>test1</p>", "<p>test2</p>");
+
+    assert.ok(!same);
+  });
+
+  await t.test("firstDiff", async () => {
+    const diff = await firstDiff("<p>test1</p>", "<p>test2</p>");
+
+    assert.strictEqual(diff.actual, "<p>test1</p>");
+    assert.strictEqual(diff.expected, "<p>test2</p>");
+  });
+
+  await t.test("firstDiff padding", async () => {
+    const diff = await firstDiff("<p>test1</p>", "<p>test2</p>", 5);
+
+    assert.strictEqual(diff.actual, "<p>test1");
+    assert.strictEqual(diff.expected, "<p>test2");
+  });
+});

package/test/output-table.test.js

@@ -0,0 +1,24 @@
+import { outputCompletionTable } from "../src/index.js";
+import test from "node:test";
+import assert from "node:assert";
+
+test("output-table", (t) => {
+  t.test("outputCompletionTable", () => {
+    let output = "";
+    t.mock.method(console, "log", (...args) => {
+      output += args.join(" ") + "\n";
+    });
+    const tests = {
+      Tests: {
+        total: 1,
+        pass: 1,
+      },
+    };
+    outputCompletionTable("Title", tests);
+
+    assert.strictEqual(
+      output,
+      "----------------------\n|        Title       |\n|                    |\n| Tests 1 of 1  100% |\n----------------------\n\n",
+    );
+  });
+});

package/test/run-tests.test.js

@@ -0,0 +1,8 @@
+import { runAllMarkedSpecTests } from "../src/index.js";
+import test from "node:test";
+
+test("run-tests", async (t) => {
+  await t.test("runAllMarkedSpecTests", async () => {
+    await runAllMarkedSpecTests();
+  });
+});