html-validate 7.11.1 → 7.12.0

package/dist/es/core.js

@@ -303,6 +303,10 @@ class Attribute {
         if (this.value instanceof DynamicValue) {
             return dynamicMatches;
         }
+        /* test against an array of keywords */
+        if (Array.isArray(pattern)) {
+            return pattern.includes(this.value);
+        }
         /* test value against pattern */
         if (pattern instanceof RegExp) {
             return this.value.match(pattern) !== null;
@@ -466,6 +470,7 @@ const MetaCopyableProperty = [
     "interactive",
     "transparent",
     "form",
+    "formAssociated",
     "labelable",
     "attributes",
     "permittedContent",
@@ -1656,6 +1661,10 @@ class UserError extends NestedError {
         Error.captureStackTrace(this, UserError);
         this.name = UserError.name;
     }
+    /**
+     * @public
+     */
+    /* istanbul ignore next: default implementation */
     prettyFormat() {
         return undefined;
     }
@@ -1878,6 +1887,10 @@ const patternProperties = {
 				title: "Mark element as a submittable form element",
 				type: "boolean"
 			},
+			formAssociated: {
+				title: "Mark element as a form-associated element",
+				$ref: "#/definitions/FormAssociated"
+			},
 			labelable: {
 				title: "Mark this element as labelable",
 				description: "This element may contain an associated label element.",
@@ -2023,6 +2036,16 @@ const definitions = {
 			}
 		}
 	},
+	FormAssociated: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			listed: {
+				type: "boolean",
+				title: "Listed elements have a name attribute and is listed in the form and fieldset elements property."
+			}
+		}
+	},
 	Permitted: {
 		type: "array",
 		items: {
@@ -2281,6 +2304,9 @@ function migrateAttributes(src) {
 function migrateElement(src) {
     const result = {
         ...src,
+        ...{
+            formAssociated: undefined,
+        },
         attributes: migrateAttributes(src),
         textContent: src.textContent,
     };
@@ -2291,6 +2317,14 @@ function migrateElement(src) {
     if (!result.textContent) {
         delete result.textContent;
     }
+    if (src.formAssociated) {
+        result.formAssociated = {
+            listed: Boolean(src.formAssociated.listed),
+        };
+    }
+    else {
+        delete result.formAssociated;
+    }
     return result;
 }
 
@@ -3453,6 +3487,16 @@ class Rule {
     isKeywordIgnored(keyword, matcher = (list, it) => list.includes(it)) {
         return isKeywordIgnored(this.options, keyword, matcher);
     }
+    /**
+     * Get [[MetaElement]] for the given tag. If no specific metadata is present
+     * the global metadata is returned or null if no global is present.
+     *
+     * @public
+     * @returns A shallow copy of metadata.
+     */
+    getMetaFor(tagName) {
+        return this.meta.getMetaFor(tagName);
+    }
     /**
      * Find all tags which has enabled given property.
      */
@@ -4863,7 +4907,7 @@ class AttributeMisuse extends Rule {
         if (!meta || !meta.allowed) {
             return;
         }
-        const details = meta.allowed(node);
+        const details = meta.allowed(node, attr);
         if (details) {
             this.report({
                 node,
@@ -5887,12 +5931,92 @@ class EmptyTitle extends Rule {
     }
 }
 
+const CACHE_KEY = Symbol("form-elements");
+function haveName(name) {
+    return typeof name === "string" && name !== "";
+}
+function isRelevant$4(node) {
+    if (node.is("input")) {
+        /* ignore radiobuttons and checkboxes */
+        const type = node.getAttribute("type");
+        return !type || !type.valueMatches(["radio", "checkbox"], true);
+    }
+    return true;
+}
+class FormDupName extends Rule {
+    documentation() {
+        return {
+            description: "Each form control must have a unique name.",
+            url: "https://html-validate.org/rules/form-dup-name.html",
+        };
+    }
+    setup() {
+        const selector = this.getSelector();
+        this.on("dom:ready", (event) => {
+            var _a;
+            const { document } = event;
+            const controls = document.querySelectorAll(selector).filter(isRelevant$4);
+            for (const control of controls) {
+                const attr = control.getAttribute("name");
+                const name = attr === null || attr === void 0 ? void 0 : attr.value;
+                if (attr && haveName(name)) {
+                    const form = (_a = control.closest("form")) !== null && _a !== void 0 ? _a : document.root;
+                    this.validateName(control, form, attr, name);
+                }
+            }
+        });
+    }
+    validateName(control, form, attr, name) {
+        const elements = this.getElements(form);
+        if (elements.has(name)) {
+            const context = {
+                name,
+            };
+            this.report({
+                node: control,
+                location: attr.valueLocation,
+                message: 'Duplicate form control name "{{ name }}"',
+                context,
+            });
+        }
+        else {
+            elements.add(name);
+        }
+    }
+    getSelector() {
+        const tags = this.getTagsWithProperty("formAssociated").filter((it) => {
+            return this.isListedElement(it);
+        });
+        return tags.join(", ");
+    }
+    isListedElement(tagName) {
+        const meta = this.getMetaFor(tagName);
+        /* istanbul ignore if: the earlier check for getTagsWithProperty ensures
+         * these will actually be set so this is just an untestable fallback */
+        if (!meta || !meta.formAssociated) {
+            return false;
+        }
+        return meta.formAssociated.listed;
+    }
+    getElements(form) {
+        const existing = form.cacheGet(CACHE_KEY);
+        if (existing) {
+            return existing;
+        }
+        else {
+            const elements = new Set();
+            form.cacheSet(CACHE_KEY, elements);
+            return elements;
+        }
+    }
+}
+
 const defaults$j = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
 };
-function isRelevant$2(event) {
+function isRelevant$3(event) {
     const node = event.target;
     return Boolean(node.meta && node.meta.heading);
 }
@@ -5960,7 +6084,7 @@ class HeadingLevel extends Rule {
         };
     }
     setup() {
-        this.on("tag:start", isRelevant$2, (event) => this.onTagStart(event));
+        this.on("tag:start", isRelevant$3, (event) => this.onTagStart(event));
         this.on("tag:ready", (event) => this.onTagReady(event));
         this.on("tag:close", (event) => this.onTagClose(event));
     }
@@ -6494,6 +6618,42 @@ class MapDupName extends Rule {
     }
 }
 
+function isRelevant$2(event) {
+    return event.target.is("map");
+}
+function hasStaticValue(attr) {
+    return Boolean(attr && !(attr.value instanceof DynamicValue));
+}
+class MapIdName extends Rule {
+    documentation() {
+        return {
+            description: "When the `id` attribute is present on a `<map>` element it must be equal to the `name` attribute.",
+            url: "https://html-validate.org/rules/map-id-name.html",
+        };
+    }
+    setup() {
+        this.on("tag:ready", isRelevant$2, (event) => {
+            var _a;
+            const { target } = event;
+            const id = target.getAttribute("id");
+            const name = target.getAttribute("name");
+            // /* ignore missing attributes or dynamic value */
+            if (!hasStaticValue(id) || !hasStaticValue(name)) {
+                return;
+            }
+            /* ignore when id and name is the same */
+            if (id.value === name.value) {
+                return;
+            }
+            this.report({
+                node: event.target,
+                message: `"id" and "name" attribute must be the same on <map> elements`,
+                location: (_a = id.valueLocation) !== null && _a !== void 0 ? _a : name.valueLocation,
+            });
+        });
+    }
+}
+
 class MissingDoctype extends Rule {
     documentation() {
         return {
@@ -8958,12 +9118,14 @@ const bundledRules = {
     "element-required-content": ElementRequiredContent,
     "empty-heading": EmptyHeading,
     "empty-title": EmptyTitle,
+    "form-dup-name": FormDupName,
     "heading-level": HeadingLevel,
     "id-pattern": IdPattern,
     "input-attributes": InputAttributes,
     "input-missing-label": InputMissingLabel,
     "long-title": LongTitle,
     "map-dup-name": MapDupName,
+    "map-id-name": MapIdName,
     "meta-refresh": MetaRefresh,
     "missing-doctype": MissingDoctype,
     "multiple-labeled-controls": MultipleLabeledControls,
@@ -9072,9 +9234,11 @@ const config$1 = {
         "element-required-content": "error",
         "empty-heading": "error",
         "empty-title": "error",
+        "form-dup-name": "error",
         "input-attributes": "error",
         "long-title": "error",
         "map-dup-name": "error",
+        "map-id-name": "error",
         "meta-refresh": "error",
         "multiple-labeled-controls": "error",
         "no-autoplay": ["error", { include: ["audio", "video"] }],
@@ -9135,6 +9299,7 @@ const config = {
         "element-required-attributes": "error",
         "element-required-content": "error",
         "map-dup-name": "error",
+        "map-id-name": "error",
         "multiple-labeled-controls": "error",
         "no-deprecated-attr": "error",
         "no-dup-attr": "error",
@@ -9964,6 +10129,8 @@ class Parser {
         }
         /* resolve any dynamic meta element properties */
         this.dom.resolveMeta(this.metaTable);
+        /* enable cache on root element, all children already have cached enabled */
+        this.dom.root.cacheEnable();
         /* trigger any rules waiting for DOM ready */
         this.trigger("dom:ready", {
             document: this.dom,
@@ -10795,6 +10962,8 @@ class Engine {
             var _a, _b;
             /* wait for a tag to open and find the current block by using its parent */
             if (directiveBlock === null) {
+                /* istanbul ignore next: there will always be a parent (root element if
+                 * nothing else) but typescript doesn't know that */
                 directiveBlock = (_b = (_a = data.target.parent) === null || _a === void 0 ? void 0 : _a.unique) !== null && _b !== void 0 ? _b : null;
             }
             /* disable rules directly on the node so it will be recorded for later,
@@ -11223,7 +11392,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.11.1";
+const version = "7.12.0";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
@@ -11666,5 +11835,5 @@ function getFormatter(name) {
     return (_a = availableFormatters[name]) !== null && _a !== void 0 ? _a : null;
 }
 
-export { Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, HtmlValidate as H, MetaTable as M, NodeClosed as N, Parser as P, Rule as R, Severity as S, TextNode as T, UserError as U, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, NestedError as f, MetaCopyableProperty as g, Reporter as h, TemplateExtractor as i, definePlugin as j, getFormatter as k, legacyRequire as l, ensureError as m, configDataFromFile as n, compatibilityCheck as o, presets as p, codeframe as q, ruleExists as r, sliceLocation as s, isTextNode as t, isElementNode as u, version as v, generateIdSelector as w, name as x, bugs as y };
+export { Attribute as A, Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, HtmlValidate as H, MetaTable as M, NodeClosed as N, Parser as P, Rule as R, Severity as S, TextNode as T, UserError as U, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, NestedError as f, MetaCopyableProperty as g, Reporter as h, TemplateExtractor as i, definePlugin as j, getFormatter as k, legacyRequire as l, ensureError as m, configDataFromFile as n, compatibilityCheck as o, presets as p, codeframe as q, ruleExists as r, sliceLocation as s, isTextNode as t, isElementNode as u, version as v, generateIdSelector as w, name as x, bugs as y };
 //# sourceMappingURL=core.js.map