html-validate 7.12.1 → 7.12.2

package/dist/es/core.js

@@ -3621,7 +3621,7 @@ class Rule {
     }
 }
 
-const defaults$v = {
+const defaults$w = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3665,7 +3665,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$v, ...options });
+        super({ ...defaults$w, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3813,7 +3813,7 @@ var RuleContext$1;
     RuleContext["MISSING_ALT"] = "missing-alt";
     RuleContext["MISSING_HREF"] = "missing-href";
 })(RuleContext$1 || (RuleContext$1 = {}));
-const defaults$u = {
+const defaults$v = {
     accessible: true,
 };
 function findByTarget(target, siblings) {
@@ -3851,7 +3851,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
     constructor(options) {
-        super({ ...defaults$u, ...options });
+        super({ ...defaults$v, ...options });
     }
     static schema() {
         return {
@@ -4020,13 +4020,13 @@ class ConfigError extends UserError {
     }
 }
 
-const defaults$t = {
+const defaults$u = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$t, ...options });
+        super({ ...defaults$u, ...options });
         this.style = new CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -4371,7 +4371,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$s = {
+const defaults$t = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4408,7 +4408,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$s, ...options });
+        super({ ...defaults$t, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4469,7 +4469,7 @@ var QuoteStyle;
     QuoteStyle["AUTO_QUOTE"] = "auto";
     QuoteStyle["ANY_QUOTE"] = "any";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$r = {
+const defaults$s = {
     style: "auto",
     unquoted: false,
 };
@@ -4536,7 +4536,7 @@ class AttrQuotes extends Rule {
         };
     }
     constructor(options) {
-        super({ ...defaults$r, ...options });
+        super({ ...defaults$s, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     setup() {
@@ -4706,12 +4706,12 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$q = {
+const defaults$r = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$q, ...options });
+        super({ ...defaults$r, ...options });
         this.hasInvalidStyle = parseStyle$3(this.options.style);
     }
     static schema() {
@@ -4787,12 +4787,12 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$p = {
+const defaults$q = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$q, ...options });
         this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
@@ -4948,12 +4948,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$o = {
+const defaults$p = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$p, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5062,13 +5062,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$n = {
+const defaults$o = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$o, ...options });
     }
     static schema() {
         return {
@@ -5231,12 +5231,12 @@ let NoStyleTag$1 = class NoStyleTag extends Rule {
     }
 };
 
-const defaults$m = {
+const defaults$n = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$n, ...options });
     }
     static schema() {
         return {
@@ -5268,12 +5268,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$l = {
+const defaults$m = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$m, ...options });
         this.style = new CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -5339,14 +5339,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$k = {
+const defaults$l = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$l, ...options });
         // eslint-disable-next-line security/detect-non-literal-regexp
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -5387,7 +5387,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$k.pattern) {
+        if (context.pattern !== defaults$l.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -5931,29 +5931,70 @@ class EmptyTitle extends Rule {
     }
 }
 
+const defaults$k = {
+    allowArrayBrackets: true,
+    shared: ["radio"],
+};
 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 allowSharedName(node) {
+function allowSharedName(node, shared) {
     const type = node.getAttribute("type");
-    return Boolean(type && type.valueMatches(["radio", "checkbox"], false));
+    return Boolean(type && type.valueMatches(shared, false));
+}
+function getDocumentation(context) {
+    const trailer = "Each form control must have a unique name.";
+    if (!context) {
+        return trailer;
+    }
+    else {
+        const { name } = context;
+        switch (context.kind) {
+            case "duplicate":
+                return [`Duplicate form control name "${name}"`, trailer].join("\n");
+            case "mix":
+                return [
+                    `Form control name cannot mix regular name "{{ name }}" with array brackets "{{ name }}[]"`,
+                    trailer,
+                ].join("\n");
+        }
+    }
 }
 class FormDupName extends Rule {
-    documentation() {
+    constructor(options) {
+        super({ ...defaults$k, ...options });
+    }
+    static schema() {
         return {
-            description: "Each form control must have a unique name.",
+            allowArrayBrackets: {
+                type: "boolean",
+            },
+            shared: {
+                type: "array",
+                items: {
+                    enum: ["radio", "checkbox", "submit"],
+                },
+            },
+        };
+    }
+    documentation(context) {
+        return {
+            description: getDocumentation(context),
             url: "https://html-validate.org/rules/form-dup-name.html",
         };
     }
     setup() {
         const selector = this.getSelector();
+        const { shared } = this.options;
         this.on("dom:ready", (event) => {
             var _a, _b;
             const { document } = event;
             const controls = document.querySelectorAll(selector);
-            const [sharedControls, uniqueControls] = partition(controls, allowSharedName);
+            const [sharedControls, uniqueControls] = partition(controls, (it) => {
+                return allowSharedName(it, shared);
+            });
             /* validate all form controls which require unique elements first so each
              * form has a populated list of unique names */
             for (const control of uniqueControls) {
@@ -5980,9 +6021,35 @@ class FormDupName extends Rule {
     }
     validateUniqueName(control, form, attr, name) {
         const elements = this.getUniqueElements(form);
+        const { allowArrayBrackets } = this.options;
+        if (allowArrayBrackets) {
+            const isarray = name.endsWith("[]");
+            const basename = isarray ? name.slice(0, -2) : name;
+            const details = elements.get(basename);
+            if (details && details.array !== isarray) {
+                const context = {
+                    name: basename,
+                    kind: "mix",
+                };
+                this.report({
+                    node: control,
+                    location: attr.valueLocation,
+                    message: 'Cannot mix "{{ name }}[]" and "{{ name }}"',
+                    context,
+                });
+                return;
+            }
+            else if (!details && isarray) {
+                elements.set(basename, {
+                    array: true,
+                });
+                return;
+            }
+        }
         if (elements.has(name)) {
             const context = {
                 name,
+                kind: "duplicate",
             };
             this.report({
                 node: control,
@@ -5992,7 +6059,9 @@ class FormDupName extends Rule {
             });
         }
         else {
-            elements.add(name);
+            elements.set(name, {
+                array: false,
+            });
         }
     }
     validateSharedName(control, form, attr, name) {
@@ -6005,6 +6074,7 @@ class FormDupName extends Rule {
             (sharedElements.has(name) && sharedElements.get(name) !== type)) {
             const context = {
                 name,
+                kind: "duplicate",
             };
             this.report({
                 node: control,
@@ -6036,7 +6106,7 @@ class FormDupName extends Rule {
             return existing;
         }
         else {
-            const elements = new Set();
+            const elements = new Map();
             form.cacheSet(UNIQUE_CACHE_KEY, elements);
             return elements;
         }
@@ -11435,7 +11505,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.12.1";
+const version = "7.12.2";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";