html-validate 11.4.0 → 11.5.1

package/dist/esm/core-nodejs.js

@@ -1,5 +1,5 @@
 import fs, { existsSync } from 'node:fs';
-import { m as StaticConfigLoader, i as PerformanceTracker, a1 as transformSource, E as Engine, P as Parser, a2 as transformSourceSync, $ as transformFilename, a0 as transformFilenameSync, R as Reporter, u as configurationSchema, J as isThenable, U as UserError, b as ConfigLoader, V as normalizeSource, a as ConfigError, C as Config, t as compatibilityCheckImpl, a3 as version } from './core.js';
+import { S as StaticConfigLoader, P as PerformanceTracker, t as transformSource, E as Engine, a as Parser, b as transformSourceSync, c as transformFilename, d as transformFilenameSync, R as Reporter, e as configurationSchema, i as isThenable, U as UserError, C as ConfigLoader, n as normalizeSource, g as ConfigError, h as Config, M as MetaTable, p as parseSeverity, j as ResolvedConfig, f as compatibilityCheckImpl, v as version } from './core.js';
 import path from 'node:path';
 import fs$1 from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
@@ -690,7 +690,7 @@ function findConfigurationFiles(fs2, directory) {
 function normalizeFilename(filename) {
   return filename === "/dev/stdin" ? path.join(process.cwd(), "noop.html") : filename;
 }
-const defaultResolvers = [esmResolver()];
+const defaultResolvers$1 = [esmResolver()];
 function hasResolver(value) {
   return Array.isArray(value[0]);
 }
@@ -705,7 +705,7 @@ class FileSystemConfigLoader extends ConfigLoader {
       options.fs ?? fs;
     } else {
       const [config, options = {}] = args;
-      super(defaultResolvers, config);
+      super(defaultResolvers$1, config);
       this.fs = /* istanbul ignore next */
       options.fs ?? fs;
     }
@@ -897,6 +897,214 @@ class FileSystemConfigLoader extends ConfigLoader {
   }
 }
 
+function defineFlatConfig(config) {
+  return config;
+}
+
+const FLAT_CONFIG_FILES = [
+  "html-validate.config.mjs",
+  "html-validate.config.cjs",
+  "html-validate.config.js",
+  "html-validate.config.mts",
+  "html-validate.config.cts",
+  "html-validate.config.ts"
+];
+function findFlatConfigFile(startDir) {
+  let current = path.resolve(startDir);
+  const root = path.parse(current).root;
+  for (; ; ) {
+    for (const filename of FLAT_CONFIG_FILES) {
+      const candidate = path.join(current, filename);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(current);
+    if (current === root || parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+async function loadFlatConfigFile(filePath) {
+  const url = pathToFileURL(filePath);
+  const stat = await fs$1.stat(url);
+  url.searchParams.append("mtime", String(stat.mtime.getTime()));
+  const module = await import(url.href);
+  const value = module.default;
+  if (!Array.isArray(value)) {
+    throw new TypeError(
+      `Flat config file "${filePath}" must have a default export that is an array`
+    );
+  }
+  return value;
+}
+
+function mergeFlatConfig(blocks) {
+  const merged = {
+    elements: [],
+    plugins: [],
+    transform: {},
+    rules: {}
+  };
+  for (const block of blocks) {
+    if (block.elements) {
+      merged.elements = [...merged.elements, ...block.elements];
+    }
+    if (block.plugins) {
+      merged.plugins = [...merged.plugins, ...block.plugins];
+    }
+    if (block.transform) {
+      merged.transform = { ...merged.transform, ...block.transform };
+    }
+    if (block.rules) {
+      merged.rules = { ...merged.rules, ...block.rules };
+    }
+  }
+  return merged;
+}
+
+function isGlobalIgnore(block) {
+  return block.ignores !== void 0 && block.files === void 0 && block.elements === void 0 && block.plugins === void 0 && block.transform === void 0 && block.rules === void 0;
+}
+function matchesFile(block, rel) {
+  if (block.ignores?.some((it) => path.matchesGlob(rel, it))) {
+    return false;
+  }
+  if (!block.files) {
+    return true;
+  }
+  return block.files.some((it) => path.matchesGlob(rel, it.includes("/") ? it : `**/${it}`));
+}
+function configDataToFlatConfigObject(data) {
+  if (!data) {
+    return {};
+  }
+  const elements = data.elements?.filter((it) => typeof it !== "string");
+  const plugins = data.plugins?.filter((it) => typeof it !== "string");
+  const rules = data.rules;
+  return {
+    elements,
+    plugins,
+    rules
+  };
+}
+function buildResolvedConfig(merged, original) {
+  const metaTable = new MetaTable();
+  for (const element of merged.elements) {
+    metaTable.loadFromObject(element);
+  }
+  metaTable.init();
+  const plugins = merged.plugins;
+  const rules = /* @__PURE__ */ new Map();
+  for (const [ruleId, data] of Object.entries(merged.rules)) {
+    let rawSeverity;
+    let options;
+    if (!Array.isArray(data)) {
+      rawSeverity = data;
+      options = {};
+    } else if (data.length === 1) {
+      rawSeverity = data[0];
+      options = {};
+    } else {
+      rawSeverity = data[0];
+      options = data[1];
+    }
+    rules.set(ruleId, [parseSeverity(rawSeverity), options]);
+  }
+  const transformers = Object.entries(merged.transform).map(
+    /* eslint-disable-next-line security/detect-non-literal-regexp -- transform patterns are user-provided regexp strings */
+    ([pattern, fn]) => ({ kind: "function", pattern: new RegExp(pattern), function: fn })
+  );
+  const resolvedData = { metaTable, plugins, rules, transformers };
+  return new ResolvedConfig(resolvedData, original);
+}
+const defaultResolvers = [esmResolver()];
+class FlatConfigLoader extends ConfigLoader {
+  configFilePath;
+  configCache;
+  fileCache;
+  /**
+   * @param configFilePath - Absolute path to the flat config file.
+   * @param resolvers - Resolvers to use.
+   */
+  constructor(configFilePath, resolvers = defaultResolvers) {
+    super(resolvers);
+    this.configFilePath = configFilePath;
+    this.configCache = null;
+    this.fileCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Search `dir` and its ancestors for a flat config file and, if found,
+   * return a new `FlatConfigLoader` pointed at it.  Returns `null` when no
+   * config file can be found.
+   *
+   * @param dir - Directory to start searching from.
+   * @param resolvers - Resolvers to use.
+   */
+  static fromDirectory(dir, resolvers) {
+    const configFilePath = findFlatConfigFile(dir);
+    if (!configFilePath) {
+      return null;
+    }
+    return new FlatConfigLoader(configFilePath, resolvers);
+  }
+  /**
+   * Get configuration for the given filename.
+   *
+   * Do note that if `configOverride` is changed between calls the cache must be
+   * flushed in-between. This loader caches the final merged result.
+   *
+   * @param filename - Absolute or relative path to the file being validated.
+   * @param configOverride - Optional configuration to merge into the result.
+   */
+  async getConfigFor(filename, configOverride) {
+    const cached = this.fileCache.get(filename);
+    if (cached) {
+      return cached;
+    }
+    const { flatConfig, globalIgnores } = await this.loadConfig();
+    const configDir = path.dirname(this.configFilePath);
+    const rel = path.relative(configDir, path.resolve(filename));
+    if (globalIgnores.some((p) => path.matchesGlob(rel, p))) {
+      return buildResolvedConfig({ elements: [], plugins: [], transform: {}, rules: {} }, []);
+    }
+    const overrideBlock = configDataToFlatConfigObject(configOverride);
+    const matchingBlocks = flatConfig.filter((block) => matchesFile(block, rel));
+    const blocks = [...matchingBlocks, overrideBlock];
+    const merged = mergeFlatConfig(blocks);
+    const resolved = buildResolvedConfig(merged, blocks);
+    this.fileCache.set(filename, resolved);
+    return resolved;
+  }
+  /**
+   * Flush the cached flat config, forcing a reload on the next call.
+   */
+  flushCache(handle) {
+    if (handle) {
+      this.fileCache.delete(handle);
+    } else {
+      this.configCache = null;
+      this.fileCache = /* @__PURE__ */ new Map();
+    }
+  }
+  /* istanbul ignore next */
+  defaultConfig() {
+    return this.empty();
+  }
+  async loadConfig() {
+    if (this.configCache) {
+      return this.configCache;
+    }
+    const raw = await loadFlatConfigFile(this.configFilePath);
+    const flatConfig = raw.filter((block) => !isGlobalIgnore(block));
+    const globalIgnores = raw.filter(isGlobalIgnore).flatMap((block) => block.ignores);
+    this.configCache = { flatConfig, globalIgnores };
+    return this.configCache;
+  }
+}
+
 const defaults = {
   silent: false,
   version,
@@ -911,5 +1119,5 @@ function compatibilityCheck(name, declared, options) {
   });
 }
 
-export { FileSystemConfigLoader as F, HtmlValidate as H, compatibilityCheck as a, cjsResolver as c, esmResolver as e, legacyRequire as l };
+export { FlatConfigLoader as F, HtmlValidate as H, FileSystemConfigLoader as a, compatibilityCheck as b, cjsResolver as c, defineFlatConfig as d, esmResolver as e, legacyRequire as l };
 //# sourceMappingURL=core-nodejs.js.map