@elliemae/pui-cli 9.0.0-next.3 → 9.0.0-next.31

package/dist/esm/commands/lint.js

@@ -1,14 +1,24 @@
 import path from "node:path";
+import { inspect } from "node:util";
 import yargs from "yargs";
 import {
   exec,
+  logInfo,
   logError,
   logSuccess,
   getCIEnv,
   isTypeScriptEnabled
 } from "./utils.js";
-const lintCSS = async (fix = false) => {
-  const fixIssues = fix ? "--fix" : "";
+const lintCSS = async (args) => {
+  const fixIssues = args.fix ? "--fix" : "";
+  if (args.debug) {
+    const configPath = path.join(process.cwd(), "stylelint.config.cjs");
+    const config = await import(configPath);
+    logInfo("stylelint version:");
+    await exec(`stylelint ./{lib,app}/**/*.{js,jsx,ts,tsx} --version`);
+    logInfo("stylelint config:");
+    logInfo(inspect(config, { depth: null }));
+  }
   await exec(
     `stylelint ./{lib,app}/**/*.{js,jsx,ts,tsx} ${fixIssues} ${!getCIEnv() ? "--color" : "--no-color"} --allow-empty-input --config ${path.join(
       process.cwd(),
@@ -16,10 +26,11 @@ const lintCSS = async (fix = false) => {
     )}`
   );
 };
-const lintJS = async (fix = false) => {
-  const fixIssues = fix ? "--fix" : "";
+const lintJS = async (args) => {
+  const fixIssues = args.fix ? "--fix" : "";
+  const debugFlags = args.debug ? "--env-info --debug" : "";
   await exec(
-    `eslint ${!getCIEnv() ? "--color" : "--no-color"} ${fixIssues}  .`
+    `eslint ${!getCIEnv() ? "--color" : "--no-color"} ${fixIssues} ${debugFlags} .`
   );
 };
 const cmdArgs = {
@@ -37,6 +48,11 @@ const cmdArgs = {
     boolean: true,
     alias: "fix",
     default: false
+  },
+  debug: {
+    boolean: true,
+    alias: "debug",
+    default: false
   }
 };
 const lintCmd = {
@@ -46,10 +62,12 @@ const lintCmd = {
         await exec("tsc --noEmit --emitDeclarationOnly false");
       try {
         await exec("rimraf ./reports/eslint.json");
-        await lintJS(argv.fix);
+        await lintJS({ ...argv });
         logSuccess("JS linting completed");
       } catch (err) {
         logError("JS linting failed");
+        if (argv.debug)
+          logError(err);
         yargs().exit(-1, err);
         return;
       }
@@ -57,10 +75,12 @@ const lintCmd = {
     if (argv.css) {
       try {
         await exec("rimraf ./reports/stylelint.json");
-        await lintCSS(argv.fix);
+        await lintCSS({ ...argv });
         logSuccess("CSS linting completed");
       } catch (err) {
         logError("CSS linting failed");
+        if (argv.debug)
+          logError(err);
         yargs().exit(-1, err);
       }
     }

package/dist/esm/commands/start.js

@@ -5,7 +5,7 @@ import { exec, logError, logSuccess, isApp } from "./utils.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const startProdServer = async () => {
   await exec(
-    `cross-env NODE_ENV=production ts-node --esm ${path.resolve(
+    `cross-env NODE_ENV=production tsx ${path.resolve(
       __dirname,
       "../server/index.js"
     )} --color always`

package/dist/esm/commands/storybook.js

@@ -3,12 +3,12 @@ import { exec, logInfo, logError, logSuccess } from "./utils.js";
 const buildStoryBook = async (outputDir = "demo", isDoc = false) => {
   const additionalParams = isDoc ? `--docs -o ${outputDir}/docs` : `-o ${outputDir}`;
   await exec(
-    `cross-env NODE_ENV=production build-storybook --quiet ${additionalParams}`
+    `cross-env NODE_ENV=production storybook build --quiet ${additionalParams}`
   );
 };
 const startStoryBook = async (isDoc = false) => {
   await exec(
-    `cross-env NODE_ENV=development STORYBOOK_BUILD=true start-storybook ${isDoc ? "--docs" : ""} -p 11000 --quiet`
+    `cross-env STORYBOOK_BUILD=true storybook dev ${isDoc ? "--docs" : ""} -p 11000 --quiet`
   );
 };
 const cmdArgs = {

package/dist/esm/commands/test.js

@@ -1,13 +1,5 @@
 import yargs from "yargs";
 import { exec, logError, logSuccess, getCIEnv } from "./utils.js";
-const test = async (commandOptions) => {
-  await exec(`cross-env NODE_ENV=test jest ${commandOptions}`);
-};
-const debugTest = async () => {
-  await exec(
-    `node --inspect-brk ./node_modules/jest-cli/bin/jest.js --runInBand --watch`
-  );
-};
 const cmdArgs = {
   fix: {
     boolean: true,
@@ -38,24 +30,61 @@ const cmdArgs = {
     boolean: true,
     alias: "s",
     default: false
+  },
+  coverage: {
+    string: true,
+    // we want to support "CI" | "false" | "true"
+    default: "true"
+  },
+  maxWorkers: {
+    string: true,
+    default: "50%"
   }
 };
+const getJestFlags = (argv) => {
+  const flagsArray = [
+    argv.maxWorkers ? `--maxWorkers=${argv.maxWorkers}` : ""
+  ];
+  const isCi = getCIEnv();
+  switch (`${argv.coverage}`) {
+    case "CI":
+      if (isCi) {
+        flagsArray.push("--coverage");
+      }
+      break;
+    case "false":
+      break;
+    case "true":
+    default:
+      flagsArray.push("--coverage");
+      break;
+  }
+  if (argv.fix)
+    flagsArray.push("-u");
+  else if (argv.watch)
+    flagsArray.push("--watchAll");
+  if (argv.passWithNoTests)
+    flagsArray.push("--passWithNoTests");
+  if (argv.findReleatedTests)
+    flagsArray.push("--bail --findRelatedTests");
+  if (argv.silent)
+    flagsArray.push("--silent");
+  if (isCi)
+    flagsArray.push("--ci --no-colors");
+  return flagsArray.join(" ");
+};
+const test = async (argv) => {
+  const jestFlags = getJestFlags(argv);
+  await exec(`cross-env NODE_ENV=test jest ${jestFlags}`);
+};
+const debugTest = async () => {
+  await exec(
+    `node --inspect-brk ./node_modules/jest-cli/bin/jest.js --runInBand --watch`
+  );
+};
 const testCmd = {
   // eslint-disable-next-line max-statements
   handler: async (argv) => {
-    let commandOptions = "--coverage --maxWorkers=50%";
-    if (argv.fix)
-      commandOptions = "-u";
-    else if (argv.watch)
-      commandOptions = "--watchAll";
-    if (getCIEnv())
-      commandOptions += " --ci --no-colors";
-    if (argv.passWithNoTests)
-      commandOptions += " --passWithNoTests";
-    if (argv.findReleatedTests)
-      commandOptions += " --bail --findRelatedTests";
-    if (argv.silent)
-      commandOptions += " --silent";
     try {
       if (getCIEnv()) {
         await exec("rimraf ./reports");
@@ -63,7 +92,7 @@ const testCmd = {
       if (argv.debug) {
         await debugTest();
       } else {
-        await test(commandOptions);
+        await test(argv);
       }
       logSuccess("Unit test execution completed");
     } catch (err) {

package/dist/esm/commands/utils.js

@@ -31,6 +31,7 @@ const browsersMapping = {
 };
 const exec = async (command, options = { stdio: "inherit" }) => execaCommand(command, options);
 const logInfo = console.log;
+const logWarning = (...args) => console.log(chalk.yellow(...args));
 const logSuccess = (...args) => console.log(chalk.green(...args));
 const logError = console.error;
 const readPackageLock = async () => {
@@ -52,7 +53,7 @@ const getSupportedBrowsers = async () => {
   return browserVersions.reduce((acc, nameVersion) => {
     const [name, version] = nameVersion.split(" ");
     const versionRange = version.split("-");
-    acc[browsersMapping[name]] = versionRange && versionRange[0] || version;
+    acc[browsersMapping[name]] = versionRange?.[0] ?? version;
     return acc;
   }, {});
 };
@@ -176,15 +177,43 @@ const isPathExist = async (pathToCheck) => {
 const isApp = async () => isPathExist(path.join(process.cwd(), "app"));
 const getCIEnv = () => process.env.CI === "true";
 const isTypeScriptEnabled = () => fs.existsSync(path.join(process.cwd(), "tsconfig.json"));
+const getUnspecifiedOptions = (options, command) => {
+  const rawArgs = process.argv.slice(2);
+  const rawArgsMap = /* @__PURE__ */ new Map();
+  rawArgs.forEach((arg) => {
+    const [key, value] = arg.split("=");
+    const keyWithoutPrefix = key.replace(/^-{1,2}/, "");
+    rawArgsMap.set(keyWithoutPrefix, value || true);
+  });
+  const expectedOptionsMap = /* @__PURE__ */ new Map();
+  Object.entries(options).forEach(([key, value]) => {
+    expectedOptionsMap.set(key, value);
+    if (value.alias)
+      expectedOptionsMap.set(value.alias, value);
+  });
+  const unspecifiedOptions = {};
+  rawArgsMap.forEach((value, key) => {
+    if (key === command)
+      return;
+    if (key === "")
+      return;
+    if (!expectedOptionsMap.has(key)) {
+      unspecifiedOptions[key] = value;
+    }
+  });
+  return unspecifiedOptions;
+};
 export {
   copyBuildAssetsToVersionedFolder,
   exec,
   getCIEnv,
+  getUnspecifiedOptions,
   isApp,
   isPathExist,
   isTypeScriptEnabled,
   logError,
   logInfo,
   logSuccess,
+  logWarning,
   writeAppInfo
 };

package/dist/esm/index.js

@@ -9,6 +9,7 @@ import { vitestConfig } from "./testing/vitest.config.js";
 import { jestNodeConfig } from "./testing/jest.node.config.cjs";
 import { lintStagedConfig } from "./lint-config/lint-staged.config.js";
 import { loadRoutes } from "./server/appRoutes.js";
+import { webpackFinal } from "./webpack/webpack.storybook.js";
 export {
   babelConfig,
   commitlintConfig,
@@ -20,5 +21,6 @@ export {
   loadRoutes,
   prettierConfig,
   stylelintConfig,
-  vitestConfig
+  vitestConfig,
+  webpackFinal
 };

package/dist/esm/lint-config/eslint/common.cjs

@@ -1,5 +1,5 @@
 /* eslint-disable max-lines */
-const prettierOptions = require("../prettier.config.cjs");
+const { prettierConfig } = require("../prettier.config.cjs");
 // const webpackConfig = require('../../webpack/webpack.prod.babel');
 
 exports.baseExtends = [
@@ -26,7 +26,7 @@ exports.baseOverrides = [
 ];
 
 const baseRules = {
-  "prettier/prettier": ["error", prettierOptions],
+  "prettier/prettier": ["error", prettierConfig],
   "arrow-body-style": [2, "as-needed"],
   "class-methods-use-this": 0,
   "import/imports-first": 0,
@@ -152,6 +152,7 @@ exports.baseConfig = {
   },
   ignorePatterns: [
     "/build/**/*",
+    "/node_modules/**/*",
     "/dist/**/*",
     "/reports/**/*",
     "/coverage/**/*",

package/dist/esm/lint-config/eslint/typescript/common.cjs

@@ -1,9 +1,9 @@
 const { baseExtends, basePlugins } = require('../common.cjs');
 
 exports.tsBaseExtends = [
-  'plugin:@typescript-eslint/recommended',
   'plugin:import/typescript',
-  'plugin:@typescript-eslint/recommended-requiring-type-checking',
+  'plugin:@typescript-eslint/recommended-type-checked',
+  'plugin:@typescript-eslint/stylistic-type-checked',
 ].concat(baseExtends);
 
 exports.tsBaseRules = {
@@ -34,7 +34,7 @@ exports.tsBaseConfig = {
   plugins: ['@typescript-eslint'].concat(basePlugins),
   parserOptions: {
     tsconfigRootDir: process.cwd(),
-    project: 'tsconfig.json',
+    project: true,
   },
   settings: {
     'import/resolver': {

package/dist/esm/lint-config/stylelint.config.cjs

@@ -1,19 +1,20 @@
 exports.stylelintConfig = {
   ignoreFiles: [
-    '/dist/**/*',
-    '/coverage/**/*',
-    '/build/**/*',
-    '/reports/**/*',
-    '/temp/**/*',
-    '/docs/**/*',
-    '/demo/**/*',
-    '/node_modules/**/*',
-    '/vendor/**/*',
+    "/dist/**/*",
+    "/coverage/**/*",
+    "/build/**/*",
+    "/reports/**/*",
+    "/temp/**/*",
+    "/docs/**/*",
+    "/demo/**/*",
+    "/node_modules/**/*",
+    "/vendor/**/*",
   ],
-  customSyntax: '@stylelint/postcss-css-in-js',
+  customSyntax: "@stylelint/postcss-css-in-js",
+  // customSyntax: "postcss-styled-components", // '@stylelint/postcss-css-in-js' is deprecated, this may be a replacement?
   extends: [
-    'stylelint-config-recommended',
-    'stylelint-config-styled-components',
+    "stylelint-config-recommended",
+    "stylelint-config-styled-components",
   ],
-  rules: { 'selector-type-no-unknown': null, 'function-no-unknown': null },
+  rules: { "selector-type-no-unknown": null, "function-no-unknown": null },
 };

package/dist/esm/monorepo/delete-merged-tags.js

@@ -3,7 +3,7 @@ const cwd = process.cwd();
 const execaOptions = { cwd, stdio: "inherit" };
 const semVerRegEx = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
 const isSemVersion = (tagName) => semVerRegEx.test(tagName);
-const branchName = (process.env.BRANCH_NAME || "master").toLowerCase();
+const branchName = (process.env.BRANCH_NAME ?? "master").toLowerCase();
 const branchTags = {
   master: /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/,
   next: /^v.*-next\.(0|[1-9]\d*)/,

package/dist/esm/monorepo/set-registry-version.js

@@ -2,7 +2,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import fg from "fast-glob";
 import normalizePath from "normalize-path";
 import { findMonoRepoRoot } from "./utils.js";
-const monorepoRoot = normalizePath(findMonoRepoRoot() || "");
+const monorepoRoot = normalizePath(findMonoRepoRoot() ?? "");
 const setRegistryVersion = async () => {
   const files = await fg([
     `${monorepoRoot}/libs/*/package.json`,

package/dist/esm/monorepo/set-workspace-version.js

@@ -2,7 +2,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import fg from "fast-glob";
 import normalizePath from "normalize-path";
 import { findMonoRepoRoot } from "./utils.js";
-const monorepoRoot = normalizePath(findMonoRepoRoot() || "");
+const monorepoRoot = normalizePath(findMonoRepoRoot() ?? "");
 const setWorkspaceVersion = async () => {
   const files = await fg([
     `${monorepoRoot}/libs/*/package.json`,

package/dist/esm/server/csp.js

@@ -1,12 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
+import crypto from "crypto";
 import express from "express";
 import cspPolicy from "helmet-csp";
-import crypto from "crypto";
 const CSP_REPORT_URI = "/diagnostics/v1/csp";
 const sources = [
   "'self'",
   "http://localhost:*",
+  "ws://localhost:*",
   "*.elliemae.io",
   "*.elliemae.com",
   "*.elliservices.com",

package/dist/esm/server/index.js

@@ -4,8 +4,9 @@ import {
   setupDefaultMiddlewares,
   setupAdditionalMiddlewars
 } from "./middlewares.js";
-import { port, host } from "./utils.js";
+import { port, wsPort, host } from "./utils.js";
 import { loadRoutes } from "./appRoutes.js";
+import { createWSServer } from "./wsServer.js";
 (async function startServer() {
   const app = express();
   setupDefaultMiddlewares(app);
@@ -17,4 +18,8 @@ import { loadRoutes } from "./appRoutes.js";
     logger.error(err);
     process.exit(1);
   });
+  const { wsServer } = await createWSServer({
+    port: wsPort
+  });
+  app.locals.wsServer = wsServer;
 })();

package/dist/esm/server/utils.js

@@ -1,13 +1,20 @@
 import minimist from "minimist";
-const argv = minimist(process.argv.slice(2));
+const argv = minimist(
+  process.argv.slice(2)
+);
 const getCWD = () => process.cwd();
 const port = parseInt(
-  argv.port || process.env.port || process.env.PORT || "3000",
+  argv.port ?? process.env.port ?? process.env.PORT ?? "3000",
+  10
+);
+const host = argv.host ?? process.env.HOST ?? "localhost";
+const wsPort = parseInt(
+  argv.wsport ?? process.env.wsport ?? process.env.WSPORT ?? "5000",
   10
 );
-const host = argv.host || process.env.HOST || "localhost";
 export {
   getCWD,
   host,
-  port
+  port,
+  wsPort
 };

package/dist/esm/server/wsServer.js

@@ -0,0 +1,99 @@
+import http from "node:http";
+import * as wsLib from "ws";
+const PING_INTERVAL = 3e4;
+const DEFAULT_PORT = 5001;
+const onSocketError = (err) => {
+  console.error(err);
+};
+const authenticate = (token, cb) => {
+  if (!token)
+    cb(4401);
+  else
+    cb();
+};
+const getAuthToken = (protocols) => {
+  const authProtocol = protocols.find(
+    (protocol) => protocol.startsWith("auth--")
+  );
+  if (!authProtocol)
+    return "";
+  return authProtocol.split("--")[1]?.trim?.();
+};
+const createWSServer = ({
+  port = DEFAULT_PORT,
+  pingInterval = PING_INTERVAL,
+  onOpen
+}) => {
+  let isAlive = false;
+  const heartbeat = () => {
+    isAlive = true;
+  };
+  const httpServer = http.createServer();
+  const wsServer = new wsLib.WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    socket.on("error", onSocketError);
+    wsServer.handleUpgrade(req, socket, head, (ws) => {
+      const protocols = req.headers["sec-websocket-protocol"]?.split(",");
+      if (!protocols) {
+        console.error("no protocols");
+        ws.close(4401, "unauthorized");
+        socket.destroy();
+        socket.removeListener("error", onSocketError);
+        return;
+      }
+      authenticate(getAuthToken(protocols) || "", (errCode) => {
+        if (errCode) {
+          switch (errCode) {
+            case 4401:
+              ws.close(errCode, "unauthorized");
+              break;
+            default:
+              ws.close(4400, "Unknown error");
+              break;
+          }
+          socket.destroy();
+          socket.removeListener("error", onSocketError);
+        } else {
+          socket.removeListener("error", onSocketError);
+          wsServer.emit("connection", ws, req);
+        }
+      });
+    });
+  });
+  wsServer.on("connection", (ws) => {
+    isAlive = true;
+    ws.on("error", console.error);
+    ws.on("pong", () => {
+      heartbeat();
+    });
+    ws.on("message", (message) => {
+      console.log(
+        "message from client:",
+        JSON.parse(message)
+      );
+      ws.send(JSON.stringify(JSON.parse(message)));
+    });
+    console.log("client connected");
+    onOpen?.(ws);
+  });
+  const interval = setInterval(() => {
+    wsServer.clients.forEach((ws) => {
+      if (isAlive === false)
+        ws.terminate();
+      isAlive = false;
+      ws.ping();
+    });
+  }, pingInterval);
+  wsServer.on("close", function close() {
+    clearInterval(interval);
+  });
+  return new Promise((resolve) => {
+    httpServer.listen(port, () => {
+      console.log(`Websocket server listening on port ${port}`);
+      return resolve({ httpServer, wsServer });
+    });
+  });
+};
+export {
+  createWSServer
+};

package/dist/esm/testing/ExtendedJSDomEnv.cjs

@@ -0,0 +1,27 @@
+const { TestEnvironment } = require('jest-environment-jsdom');
+
+// ICE platform is meant to be run on  node > 18
+//   "jest-environment-jsdom": "~29.6.3" is instead meant to support node >16
+//   features that are supported since node 17 & 18 are not supported in jsdom env
+//      the limitation is not relevant for us since we are already running on node 18 anyway,
+//      this "ExtendedJSDomEnv" is an extension of the
+//         jest.config.cjs
+//         {
+//           ...
+//           testEnvironment: 'jsdom'
+//           ...
+//         }
+//      that actually uses node 18 features that are not supported in "jest-environment-jsdom": "~29.6.3"
+
+// https://github.com/facebook/jest/blob/v29.4.3/website/versioned_docs/version-29.4/Configuration.md#testenvironment-string
+class FixJSDOMEnvironment extends TestEnvironment {
+  constructor(...args) {
+    super(...args);
+
+    // From here on we are using "node" (currently running version of it) to polyfill jsdom this.global
+
+    // FIXME https://github.com/jsdom/jsdom/issues/3363
+    if (structuredClone) this.global.structuredClone = structuredClone;
+  }
+}
+module.exports = FixJSDOMEnvironment;

package/dist/esm/testing/extended/axe-core/getMessageAndPass.js

@@ -0,0 +1,17 @@
+import { matcherHint } from "jest-matcher-utils";
+import { reporter } from "./reporter.js";
+const getMessageAndPass = (violations) => {
+  const formatedViolations = reporter(violations);
+  const pass = formatedViolations.length === 0;
+  if (pass)
+    return { message: () => "", pass };
+  return {
+    message: () => `${matcherHint(".toHaveNoViolations")}
+
+${formatedViolations}`,
+    pass
+  };
+};
+export {
+  getMessageAndPass
+};

package/dist/esm/testing/extended/axe-core/index.js

@@ -0,0 +1,4 @@
+import { toHaveNoViolations } from "./toHaveNoViolations.js";
+export {
+  toHaveNoViolations
+};

package/dist/esm/testing/extended/axe-core/reporter.js

@@ -0,0 +1,31 @@
+import { printReceived } from "jest-matcher-utils";
+const colorYellow = (arg) => `\x1B[93m ${arg ?? ""} \x1B[0m`;
+const colorGrey = (arg) => `\x1B[90m ${arg ?? ""} \x1B[0m`;
+const colorBlue = (arg) => `\x1B[34m ${arg ?? ""} \x1B[0m`;
+const reporter = (violToFormat) => {
+  if (violToFormat.length === 0)
+    return "";
+  const lineBreak = "\n\n";
+  const horizontalLine = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+  return violToFormat.map((violation) => {
+    const errorBody = violation.nodes.map((node) => {
+      const selector = node.target.join(", ");
+      const expectedText = `Expected the HTML found at $('${selector}') to have no violations:${lineBreak}`;
+      let violationHelpUrl = "";
+      if (violation.helpUrl)
+        violationHelpUrl = `You can find more information on this issue here: 
+${colorBlue(
+          violation.helpUrl
+        )}`;
+      return `${expectedText + colorGrey(node.html) + lineBreak}Received:${lineBreak}${printReceived(
+        `${violation.help} (${violation.id})`
+      )}${lineBreak}${colorYellow(
+        node.failureSummary
+      )}${lineBreak}${violationHelpUrl}`;
+    }).join(lineBreak);
+    return errorBody;
+  }).join(lineBreak + horizontalLine + lineBreak);
+};
+export {
+  reporter
+};

package/dist/esm/testing/extended/axe-core/shouldIgnoreNodeViolation.js

@@ -0,0 +1,11 @@
+const dataAttributeRegexp = /(data-[\S]*)=["']([\S]*)["']/gm;
+const shouldIgnoreNodeViolation = (node, violation) => [...node.html.matchAll(dataAttributeRegexp)].map(([fullMatch, dataKey, dataValue]) => ({
+  fullMatch,
+  dataKey,
+  dataValue
+})).some(
+  ({ dataKey, dataValue }) => dataKey === `data-axe-ignore-${violation.id}` && dataValue === "true"
+);
+export {
+  shouldIgnoreNodeViolation
+};

package/dist/esm/testing/extended/axe-core/toHaveNoViolations.js

@@ -0,0 +1,23 @@
+import { getMessageAndPass } from "./getMessageAndPass.js";
+import { shouldIgnoreNodeViolation } from "./shouldIgnoreNodeViolation.js";
+const toHaveNoViolations = {
+  toHaveNoViolations(results) {
+    const { violations } = results;
+    const finalViolations = [];
+    violations.forEach((violation) => {
+      const { nodes } = violation;
+      const newNodes = [];
+      nodes.forEach((node) => {
+        if (!shouldIgnoreNodeViolation(node, violation))
+          newNodes.push(node);
+      });
+      if (newNodes.length > 0) {
+        finalViolations.push({ ...violation, nodes: newNodes });
+      }
+    });
+    return { actual: violations, ...getMessageAndPass(finalViolations) };
+  }
+};
+export {
+  toHaveNoViolations
+};