html-validate 7.16.0 → 7.17.0

package/dist/cjs/core.js

@@ -1863,28 +1863,6 @@ function cyrb53(str) {
 }
 const computeHash = cyrb53;
 
-const legacyRequire = require;
-
-/**
- * Similar to `require(..)` but removes the cached copy first.
- */
-function requireUncached(moduleId) {
-    const filename = legacyRequire.resolve(moduleId);
-    /* remove references from the parent module to prevent memory leak */
-    const m = legacyRequire.cache[filename];
-    if (m && m.parent) {
-        const { parent } = m;
-        for (let i = parent.children.length - 1; i >= 0; i--) {
-            if (parent.children[i].id === filename) {
-                parent.children.splice(i, 1);
-            }
-        }
-    }
-    /* remove old module from cache */
-    delete legacyRequire.cache[filename];
-    return legacyRequire(filename);
-}
-
 const $schema$1 = "http://json-schema.org/draft-06/schema#";
 const $id$1 = "https://html-validate.org/schemas/elements.json";
 const type$1 = "object";
@@ -2534,29 +2512,18 @@ class MetaTable {
      */
     loadFromObject(obj, filename = null) {
         var _a;
-        const validate = this.getSchemaValidator();
-        if (!validate(obj)) {
-            throw new SchemaValidationError(filename, `Element metadata is not valid`, obj, this.schema, 
-            /* istanbul ignore next: AJV sets .errors when validate returns false */
-            (_a = validate.errors) !== null && _a !== void 0 ? _a : []);
-        }
-        for (const [key, value] of Object.entries(obj)) {
-            if (key === "$schema")
-                continue;
-            this.addEntry(key, migrateElement(value));
-        }
-    }
-    /**
-     * Load metadata table from filename
-     *
-     * @public
-     * @param filename - Filename to load
-     */
-    loadFromFile(filename) {
         try {
-            /* load using require as it can process both js and json */
-            const data = requireUncached(filename);
-            this.loadFromObject(data, filename);
+            const validate = this.getSchemaValidator();
+            if (!validate(obj)) {
+                throw new SchemaValidationError(filename, `Element metadata is not valid`, obj, this.schema, 
+                /* istanbul ignore next: AJV sets .errors when validate returns false */
+                (_a = validate.errors) !== null && _a !== void 0 ? _a : []);
+            }
+            for (const [key, value] of Object.entries(obj)) {
+                if (key === "$schema")
+                    continue;
+                this.addEntry(key, migrateElement(value));
+            }
         }
         catch (err) {
             if (err instanceof InheritError) {
@@ -2566,6 +2533,9 @@ class MetaTable {
             if (err instanceof SchemaValidationError) {
                 throw err;
             }
+            if (!filename) {
+                throw err;
+            }
             throw new UserError(`Failed to load element metadata from "${filename}"`, ensureError(err));
         }
     }
@@ -3107,7 +3077,14 @@ const properties = {
 	plugins: {
 		type: "array",
 		items: {
-			type: "string"
+			anyOf: [
+				{
+					type: "string"
+				},
+				{
+					type: "object"
+				}
+			]
 		},
 		title: "Plugins to load",
 		description: "Array of plugins load. Use <rootDir> to refer to the folder with the package.json file.",
@@ -3414,6 +3391,29 @@ var TRANSFORMER_API;
     TRANSFORMER_API[TRANSFORMER_API["VERSION"] = 1] = "VERSION";
 })(TRANSFORMER_API || (TRANSFORMER_API = {}));
 
+/**
+ * Similar to `require(..)` but removes the cached copy first.
+ */
+function requireUncached(require, moduleId) {
+    const filename = require.resolve(moduleId);
+    /* remove references from the parent module to prevent memory leak */
+    const m = require.cache[filename];
+    if (m && m.parent) {
+        const { parent } = m;
+        for (let i = parent.children.length - 1; i >= 0; i--) {
+            if (parent.children[i].id === filename) {
+                parent.children.splice(i, 1);
+            }
+        }
+    }
+    /* remove old module from cache */
+    delete require.cache[filename];
+    /* eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require -- as expected but should be moved to upcoming resolver class */
+    return require(filename);
+}
+
+const legacyRequire = require;
+
 /**
  * @public
  */
@@ -4118,6 +4118,29 @@ const whitelisted = [
     "summary",
     "figure",
 ];
+function isValidUsage(target, meta) {
+    /* elements with explicit aria-label attribute are valid */
+    if (meta.attributes["aria-label"]) {
+        return true;
+    }
+    /* landmark and other whitelisted elements are valid */
+    if (whitelisted.includes(target.tagName)) {
+        return true;
+    }
+    /* elements with role are valid, @todo check if the role is widget or landmark */
+    if (target.hasAttribute("role")) {
+        return true;
+    }
+    /* elements with tabindex (implicit interactive) are valid */
+    if (target.hasAttribute("tabindex")) {
+        return true;
+    }
+    /* interactive and labelable elements are valid */
+    if (meta.interactive || meta.labelable) {
+        return true;
+    }
+    return false;
+}
 class AriaLabelMisuse extends Rule {
     documentation() {
         const valid = [
@@ -4156,20 +4179,8 @@ class AriaLabelMisuse extends Rule {
         if (!meta) {
             return;
         }
-        /* ignore landmark and other whitelisted elements */
-        if (whitelisted.includes(target.tagName)) {
-            return;
-        }
-        /* ignore elements with role, @todo check if the role is widget or landmark */
-        if (target.hasAttribute("role")) {
-            return;
-        }
-        /* ignore elements with tabindex (implicit interactive) */
-        if (target.hasAttribute("tabindex")) {
-            return;
-        }
-        /* ignore interactive and labelable elements */
-        if (meta.interactive || meta.labelable) {
+        /* ignore elements which is valid usage */
+        if (isValidUsage(target, meta)) {
             return;
         }
         this.report(target, `"aria-label" cannot be used on this element`, attr.keyLocation);
@@ -9790,7 +9801,7 @@ function configDataFromFile(filename) {
     try {
         /* load using require as it can process both js and json */
         /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- technical debt, should be refactored into something more typesafe */
-        json = requireUncached(filename);
+        json = requireUncached(legacyRequire, filename);
     }
     catch (err) {
         throw new ConfigError(`Failed to read configuration from "${filename}"`, ensureError(err));
@@ -9961,7 +9972,6 @@ class Config {
     /**
      * Get element metadata.
      */
-    /* eslint-disable-next-line complexity, sonarjs/cognitive-complexity -- technical debt, should be refactored */
     getMetaTable() {
         /* use cached table if it exists */
         if (this.metaTable) {
@@ -9988,20 +9998,16 @@ class Config {
                 metaTable.loadFromObject(bundled);
                 continue;
             }
-            /* try as regular file */
-            const filename = entry.replace("<rootDir>", this.rootDir);
-            if (fs__default.default.existsSync(filename)) {
-                metaTable.loadFromFile(filename);
-                continue;
-            }
             /* assume it is loadable with require() */
+            const id = entry.replace("<rootDir>", this.rootDir);
             try {
-                metaTable.loadFromObject(legacyRequire(entry));
+                const data = legacyRequire(id);
+                metaTable.loadFromObject(data, id);
             }
             catch (err) {
                 /* istanbul ignore next: only used as a fallback */
                 const message = err instanceof Error ? err.message : String(err);
-                throw new ConfigError(`Failed to load elements from "${entry}": ${message}`, ensureError(err));
+                throw new ConfigError(`Failed to load elements from "${id}": ${message}`, ensureError(err));
             }
         }
         metaTable.init();
@@ -10071,7 +10077,13 @@ class Config {
         return this.plugins;
     }
     loadPlugins(plugins) {
-        return plugins.map((moduleName) => {
+        return plugins.map((moduleName, index) => {
+            if (typeof moduleName !== "string") {
+                const plugin = moduleName;
+                plugin.name = plugin.name || `:unnamedPlugin@${index + 1}`;
+                plugin.originalName = `:unnamedPlugin@${index + 1}`;
+                return plugin;
+            }
             try {
                 const plugin = legacyRequire(moduleName.replace("<rootDir>", this.rootDir));
                 plugin.name = plugin.name || moduleName;
@@ -10158,6 +10170,7 @@ class Config {
             var _a;
             try {
                 const fn = this.getTransformFunction(name);
+                /* istanbul ignore next */
                 const version = (_a = fn.api) !== null && _a !== void 0 ? _a : 0;
                 /* check if transformer version is supported */
                 if (version !== TRANSFORMER_API.VERSION) {
@@ -11549,13 +11562,13 @@ class Engine {
  * The static configuration loader does not do any per-handle lookup. Only the
  * global or per-call configuration is used.
  *
- * In practice this means no configuration is fetch by traversing the
+ * In practice this means no configuration is fetched by traversing the
  * filesystem.
  *
  * @public
  */
 class StaticConfigLoader extends ConfigLoader {
-    getConfigFor(handle, configOverride) {
+    getConfigFor(_handle, configOverride) {
         const override = this.loadFromObject(configOverride || {});
         if (override.isRootFound()) {
             override.init();
@@ -11832,7 +11845,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.16.0";
+const version = "7.17.0";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";