html-validate 10.1.1 → 10.1.2

package/dist/esm/cli.js

@@ -1,14 +1,13 @@
 import { l as legacyRequire, F as FileSystemConfigLoader, e as esmResolver, H as HtmlValidate } from './core-nodejs.js';
-import { g as getFormatter$1, U as UserError, e as ensureError, i as ignore, d as deepmerge, J as engines, B as Reporter } from './core.js';
+import { g as getFormatter$1, U as UserError, e as ensureError, d as deepmerge, i as ignore, B as Reporter, J as engines } from './core.js';
 import path$1 from 'node:path/posix';
-import fs from 'fs';
+import fs from 'node:fs';
 import path from 'node:path';
 import { globSync } from 'glob';
 import prompts from 'prompts';
 import './meta-helper.js';
-import fs$1 from 'node:fs';
-import betterAjvErrors from '@sidvind/better-ajv-errors';
 import kleur from 'kleur';
+import betterAjvErrors from '@sidvind/better-ajv-errors';
 
 const DEFAULT_EXTENSIONS = ["html"];
 function isDirectory(filename) {
@@ -99,55 +98,34 @@ function getFormatter(formatters) {
   };
 }
 
-class IsIgnored {
-  /** Cache for parsed .htmlvalidateignore files */
-  cacheIgnore;
-  constructor() {
-    this.cacheIgnore = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Searches ".htmlvalidateignore" files from filesystem and returns `true` if
-   * one of them contains a pattern matching given filename.
-   */
-  isIgnored(filename) {
-    return this.match(filename);
-  }
-  /**
-   * Clear cache
-   */
-  clearCache() {
-    this.cacheIgnore.clear();
-  }
-  match(target) {
-    let current = path.dirname(target);
-    while (true) {
-      const relative = path.relative(current, target);
-      const filename = path.join(current, ".htmlvalidateignore");
-      const ig = this.parseFile(filename);
-      if (ig?.ignores(relative)) {
-        return true;
-      }
-      const child = current;
-      current = path.dirname(current);
-      if (current === child) {
-        break;
-      }
-    }
-    return false;
+function parseSeverity(ruleId, severity) {
+  switch (severity) {
+    case "off":
+    case "0":
+      return "off";
+    case "warn":
+    case "1":
+      return "warn";
+    case "error":
+    case "2":
+      return "error";
+    default:
+      throw new Error(`Invalid severity "${severity}" for rule "${ruleId}"`);
   }
-  parseFile(filename) {
-    if (this.cacheIgnore.has(filename)) {
-      return this.cacheIgnore.get(filename);
-    }
-    if (!fs.existsSync(filename)) {
-      this.cacheIgnore.set(filename, void 0);
-      return void 0;
-    }
-    const content = fs.readFileSync(filename, "utf-8");
-    const ig = ignore().add(content);
-    this.cacheIgnore.set(filename, ig);
-    return ig;
+}
+
+function parseItem(value) {
+  const [ruleId, severity = "error"] = value.split(":", 2);
+  return { ruleId, severity: parseSeverity(ruleId, severity) };
+}
+function getRuleConfig(values) {
+  if (typeof values === "string") {
+    return getRuleConfig([values]);
   }
+  return values.reduce((parsedRules, value) => {
+    const { ruleId, severity } = parseItem(value.trim());
+    return { [ruleId]: severity, ...parsedRules };
+  }, {});
 }
 
 const frameworkConfig = {
@@ -223,34 +201,55 @@ async function init$1(cwd) {
   };
 }
 
-function parseSeverity(ruleId, severity) {
-  switch (severity) {
-    case "off":
-    case "0":
-      return "off";
-    case "warn":
-    case "1":
-      return "warn";
-    case "error":
-    case "2":
-      return "error";
-    default:
-      throw new Error(`Invalid severity "${severity}" for rule "${ruleId}"`);
+class IsIgnored {
+  /** Cache for parsed .htmlvalidateignore files */
+  cacheIgnore;
+  constructor() {
+    this.cacheIgnore = /* @__PURE__ */ new Map();
   }
-}
-
-function parseItem(value) {
-  const [ruleId, severity = "error"] = value.split(":", 2);
-  return { ruleId, severity: parseSeverity(ruleId, severity) };
-}
-function getRuleConfig(values) {
-  if (typeof values === "string") {
-    return getRuleConfig([values]);
+  /**
+   * Searches ".htmlvalidateignore" files from filesystem and returns `true` if
+   * one of them contains a pattern matching given filename.
+   */
+  isIgnored(filename) {
+    return this.match(filename);
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cacheIgnore.clear();
+  }
+  match(target) {
+    let current = path.dirname(target);
+    while (true) {
+      const relative = path.relative(current, target);
+      const filename = path.join(current, ".htmlvalidateignore");
+      const ig = this.parseFile(filename);
+      if (ig?.ignores(relative)) {
+        return true;
+      }
+      const child = current;
+      current = path.dirname(current);
+      if (current === child) {
+        break;
+      }
+    }
+    return false;
+  }
+  parseFile(filename) {
+    if (this.cacheIgnore.has(filename)) {
+      return this.cacheIgnore.get(filename);
+    }
+    if (!fs.existsSync(filename)) {
+      this.cacheIgnore.set(filename, void 0);
+      return void 0;
+    }
+    const content = fs.readFileSync(filename, "utf-8");
+    const ig = ignore().add(content);
+    this.cacheIgnore.set(filename, ig);
+    return ig;
   }
-  return values.reduce((parsedRules, value) => {
-    const { ruleId, severity } = parseItem(value.trim());
-    return { [ruleId]: severity, ...parsedRules };
-  }, {});
 }
 
 const resolver = esmResolver();
@@ -378,51 +377,53 @@ class CLI {
   }
 }
 
-function prettyError(err) {
-  let json;
-  if (err.filename && fs$1.existsSync(err.filename)) {
-    json = fs$1.readFileSync(err.filename, "utf-8");
-  }
-  return betterAjvErrors(err.schema, err.obj, err.errors, {
-    format: "cli",
-    indent: 2,
-    json
-  });
+const jsonIgnored = [
+  "annotation",
+  "blockedRules",
+  "cache",
+  "closed",
+  "depth",
+  "disabledRules",
+  "nodeType",
+  "unique",
+  "voidElement"
+];
+const jsonFiltered = [
+  "childNodes",
+  "children",
+  "data",
+  "meta",
+  "metaElement",
+  "originalData",
+  "parent"
+];
+function isLocation(key, value) {
+  return Boolean(value && (key === "location" || key.endsWith("Location")));
 }
-function handleSchemaValidationError(console, err) {
-  if (err.filename) {
-    const filename = path.relative(process.cwd(), err.filename);
-    console.error(kleur.red(`A configuration error was found in "${filename}":`));
-  } else {
-    console.error(kleur.red(`A configuration error was found:`));
-  }
-  console.group();
-  {
-    console.error(prettyError(err));
-  }
-  console.groupEnd();
+function isIgnored(key) {
+  return key.startsWith("_") || jsonIgnored.includes(key);
 }
-
-class ImportResolveMissingError extends UserError {
-  constructor() {
-    const message = `import.meta.resolve(..) is not available on this system`;
-    super(message);
-    Error.captureStackTrace(this, ImportResolveMissingError);
-    this.name = ImportResolveMissingError.name;
+function isFiltered(key, value) {
+  return Boolean(value && jsonFiltered.includes(key));
+}
+function eventReplacer(key, value) {
+  if (isLocation(key, value)) {
+    const filename = value.filename;
+    const line = String(value.line);
+    const column = String(value.column);
+    return `${filename}:${line}:${column}`;
   }
-  prettyFormat() {
-    const { message } = this;
-    const currentVersion = process.version;
-    const requiredVersion = engines.node.split("||").map((it) => `v${it.replace(/^[^\d]+/, "").trim()}`);
-    return [
-      kleur.red(`Error: ${message}.`),
-      "",
-      `Either ensure you are running a supported NodeJS version:`,
-      `  Current:  ${currentVersion}`,
-      `  Required: ${requiredVersion.join(", ")} or later`,
-      `Or set NODE_OPTIONS="--experimental-import-meta-resolve"`
-    ].join("\n");
+  if (isIgnored(key)) {
+    return void 0;
+  }
+  if (isFiltered(key, value)) {
+    return "[truncated]";
   }
+  return value;
+}
+function eventFormatter(entry) {
+  const strdata = JSON.stringify(entry.data, eventReplacer, 2);
+  return `${entry.event}: ${strdata}`;
 }
 
 var Mode = /* @__PURE__ */ ((Mode2) => {
@@ -454,6 +455,48 @@ function modeToFlag(mode) {
   }
 }
 
+async function dump(htmlvalidate, output, files, mode) {
+  let lines;
+  switch (mode) {
+    case Mode.DUMP_EVENTS:
+      lines = files.map(async (filename) => {
+        const lines2 = await htmlvalidate.dumpEvents(filename);
+        return lines2.map(eventFormatter);
+      });
+      break;
+    case Mode.DUMP_TOKENS:
+      lines = files.map(async (filename) => {
+        const lines2 = await htmlvalidate.dumpTokens(filename);
+        return lines2.map((entry) => {
+          const data = JSON.stringify(entry.data);
+          return `TOKEN: ${entry.token}
+  Data: ${data}
+  Location: ${entry.location}`;
+        });
+      });
+      break;
+    case Mode.DUMP_TREE:
+      lines = files.map((filename) => htmlvalidate.dumpTree(filename));
+      break;
+    case Mode.DUMP_SOURCE:
+      lines = files.map((filename) => htmlvalidate.dumpSource(filename));
+      break;
+    default:
+      throw new Error(`Unknown mode "${String(mode)}"`);
+  }
+  const flat = (await Promise.all(lines)).reduce((s, c) => s.concat(c), []);
+  output.write(flat.join("\n"));
+  output.write("\n");
+  return Promise.resolve(true);
+}
+
+async function init(cli, output, options) {
+  const result = await cli.init(options.cwd);
+  output.write(`Configuration written to "${result.filename}"
+`);
+  return true;
+}
+
 function renameStdin(report, filename) {
   const stdin = report.results.find((cur) => cur.filePath === "/dev/stdin");
   if (stdin) {
@@ -488,13 +531,6 @@ html-validate found too many warnings (maximum: ${String(options.maxWarnings)}).
   return merged.valid;
 }
 
-async function init(cli, output, options) {
-  const result = await cli.init(options.cwd);
-  output.write(`Configuration written to "${result.filename}"
-`);
-  return true;
-}
-
 async function printConfig(htmlvalidate, output, files) {
   if (files.length > 1) {
     output.write(`\`--print-config\` expected a single filename but got multiple:
@@ -514,88 +550,51 @@ async function printConfig(htmlvalidate, output, files) {
   return true;
 }
 
-const jsonIgnored = [
-  "annotation",
-  "blockedRules",
-  "cache",
-  "closed",
-  "depth",
-  "disabledRules",
-  "nodeType",
-  "unique",
-  "voidElement"
-];
-const jsonFiltered = [
-  "childNodes",
-  "children",
-  "data",
-  "meta",
-  "metaElement",
-  "originalData",
-  "parent"
-];
-function isLocation(key, value) {
-  return Boolean(value && (key === "location" || key.endsWith("Location")));
-}
-function isIgnored(key) {
-  return key.startsWith("_") || jsonIgnored.includes(key);
-}
-function isFiltered(key, value) {
-  return Boolean(value && jsonFiltered.includes(key));
-}
-function eventReplacer(key, value) {
-  if (isLocation(key, value)) {
-    const filename = value.filename;
-    const line = String(value.line);
-    const column = String(value.column);
-    return `${filename}:${line}:${column}`;
+function prettyError(err) {
+  let json;
+  if (err.filename && fs.existsSync(err.filename)) {
+    json = fs.readFileSync(err.filename, "utf-8");
   }
-  if (isIgnored(key)) {
-    return void 0;
+  return betterAjvErrors(err.schema, err.obj, err.errors, {
+    format: "cli",
+    indent: 2,
+    json
+  });
+}
+function handleSchemaValidationError(console, err) {
+  if (err.filename) {
+    const filename = path.relative(process.cwd(), err.filename);
+    console.error(kleur.red(`A configuration error was found in "${filename}":`));
+  } else {
+    console.error(kleur.red(`A configuration error was found:`));
   }
-  if (isFiltered(key, value)) {
-    return "[truncated]";
+  console.group();
+  {
+    console.error(prettyError(err));
   }
-  return value;
-}
-function eventFormatter(entry) {
-  const strdata = JSON.stringify(entry.data, eventReplacer, 2);
-  return `${entry.event}: ${strdata}`;
+  console.groupEnd();
 }
 
-async function dump(htmlvalidate, output, files, mode) {
-  let lines;
-  switch (mode) {
-    case Mode.DUMP_EVENTS:
-      lines = files.map(async (filename) => {
-        const lines2 = await htmlvalidate.dumpEvents(filename);
-        return lines2.map(eventFormatter);
-      });
-      break;
-    case Mode.DUMP_TOKENS:
-      lines = files.map(async (filename) => {
-        const lines2 = await htmlvalidate.dumpTokens(filename);
-        return lines2.map((entry) => {
-          const data = JSON.stringify(entry.data);
-          return `TOKEN: ${entry.token}
-  Data: ${data}
-  Location: ${entry.location}`;
-        });
-      });
-      break;
-    case Mode.DUMP_TREE:
-      lines = files.map((filename) => htmlvalidate.dumpTree(filename));
-      break;
-    case Mode.DUMP_SOURCE:
-      lines = files.map((filename) => htmlvalidate.dumpSource(filename));
-      break;
-    default:
-      throw new Error(`Unknown mode "${String(mode)}"`);
+class ImportResolveMissingError extends UserError {
+  constructor() {
+    const message = `import.meta.resolve(..) is not available on this system`;
+    super(message);
+    Error.captureStackTrace(this, ImportResolveMissingError);
+    this.name = ImportResolveMissingError.name;
+  }
+  prettyFormat() {
+    const { message } = this;
+    const currentVersion = process.version;
+    const requiredVersion = engines.node.split("||").map((it) => `v${it.replace(/^[^\d]+/, "").trim()}`);
+    return [
+      kleur.red(`Error: ${message}.`),
+      "",
+      `Either ensure you are running a supported NodeJS version:`,
+      `  Current:  ${currentVersion}`,
+      `  Required: ${requiredVersion.join(", ")} or later`,
+      `Or set NODE_OPTIONS="--experimental-import-meta-resolve"`
+    ].join("\n");
   }
-  const flat = (await Promise.all(lines)).reduce((s, c) => s.concat(c), []);
-  output.write(flat.join("\n"));
-  output.write("\n");
-  return Promise.resolve(true);
 }
 
 function haveImportMetaResolve() {