html-validate 7.12.0 → 7.12.1

package/README.md

@@ -16,7 +16,7 @@ Offline HTML5 validator. Validates either a full document or a smaller
 ## Usage
 
     npm install -g html-validate
-    html-validate FILENAME..
+    html-validate [OPTIONS] [FILENAME..] [DIR..]
 
 ## Configuration
 

package/dist/cjs/core.js

@@ -5963,17 +5963,14 @@ class EmptyTitle extends Rule {
     }
 }
 
-const CACHE_KEY = Symbol("form-elements");
+const UNIQUE_CACHE_KEY = Symbol("form-elements-unique");
+const SHARED_CACHE_KEY = Symbol("form-elements-shared");
 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;
+function allowSharedName(node) {
+    const type = node.getAttribute("type");
+    return Boolean(type && type.valueMatches(["radio", "checkbox"], false));
 }
 class FormDupName extends Rule {
     documentation() {
@@ -5985,21 +5982,36 @@ class FormDupName extends Rule {
     setup() {
         const selector = this.getSelector();
         this.on("dom:ready", (event) => {
-            var _a;
+            var _a, _b;
             const { document } = event;
-            const controls = document.querySelectorAll(selector).filter(isRelevant$4);
-            for (const control of controls) {
+            const controls = document.querySelectorAll(selector);
+            const [sharedControls, uniqueControls] = rulesHelper.partition(controls, allowSharedName);
+            /* validate all form controls which require unique elements first so each
+             * form has a populated list of unique names */
+            for (const control of uniqueControls) {
+                const attr = control.getAttribute("name");
+                const name = attr === null || attr === void 0 ? void 0 : attr.value;
+                if (!attr || !haveName(name)) {
+                    continue;
+                }
+                const form = (_a = control.closest("form")) !== null && _a !== void 0 ? _a : document.root;
+                this.validateUniqueName(control, form, attr, name);
+            }
+            /* validate all form controls which allows shared names to ensure there is
+             * no collision with other form controls */
+            for (const control of sharedControls) {
                 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);
+                if (!attr || !haveName(name)) {
+                    continue;
                 }
+                const form = (_b = control.closest("form")) !== null && _b !== void 0 ? _b : document.root;
+                this.validateSharedName(control, form, attr, name);
             }
         });
     }
-    validateName(control, form, attr, name) {
-        const elements = this.getElements(form);
+    validateUniqueName(control, form, attr, name) {
+        const elements = this.getUniqueElements(form);
         if (elements.has(name)) {
             const context = {
                 name,
@@ -6015,6 +6027,26 @@ class FormDupName extends Rule {
             elements.add(name);
         }
     }
+    validateSharedName(control, form, attr, name) {
+        var _a;
+        const uniqueElements = this.getUniqueElements(form);
+        const sharedElements = this.getSharedElements(form);
+        /* istanbul ignore next: type will always be set or shared name wouldn't be allowed */
+        const type = (_a = control.getAttributeValue("type")) !== null && _a !== void 0 ? _a : "";
+        if (uniqueElements.has(name) ||
+            (sharedElements.has(name) && sharedElements.get(name) !== type)) {
+            const context = {
+                name,
+            };
+            this.report({
+                node: control,
+                location: attr.valueLocation,
+                message: 'Duplicate form control name "{{ name }}"',
+                context,
+            });
+        }
+        sharedElements.set(name, type);
+    }
     getSelector() {
         const tags = this.getTagsWithProperty("formAssociated").filter((it) => {
             return this.isListedElement(it);
@@ -6030,14 +6062,25 @@ class FormDupName extends Rule {
         }
         return meta.formAssociated.listed;
     }
-    getElements(form) {
-        const existing = form.cacheGet(CACHE_KEY);
+    getUniqueElements(form) {
+        const existing = form.cacheGet(UNIQUE_CACHE_KEY);
         if (existing) {
             return existing;
         }
         else {
             const elements = new Set();
-            form.cacheSet(CACHE_KEY, elements);
+            form.cacheSet(UNIQUE_CACHE_KEY, elements);
+            return elements;
+        }
+    }
+    getSharedElements(form) {
+        const existing = form.cacheGet(SHARED_CACHE_KEY);
+        if (existing) {
+            return existing;
+        }
+        else {
+            const elements = new Map();
+            form.cacheSet(SHARED_CACHE_KEY, elements);
             return elements;
         }
     }
@@ -11424,7 +11467,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.12.0";
+const version = "7.12.1";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";