html-validate 7.12.0 → 7.12.2

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

@@ -3653,7 +3653,7 @@ class Rule {
     }
 }
 
-const defaults$v = {
+const defaults$w = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3697,7 +3697,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);
@@ -3845,7 +3845,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) {
@@ -3883,7 +3883,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
     constructor(options) {
-        super({ ...defaults$u, ...options });
+        super({ ...defaults$v, ...options });
     }
     static schema() {
         return {
@@ -4052,13 +4052,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 rulesHelper.CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -4403,7 +4403,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$s = {
+const defaults$t = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4440,7 +4440,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() {
@@ -4501,7 +4501,7 @@ var QuoteStyle;
     QuoteStyle["AUTO_QUOTE"] = "auto";
     QuoteStyle["ANY_QUOTE"] = "any";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$r = {
+const defaults$s = {
     style: "auto",
     unquoted: false,
 };
@@ -4568,7 +4568,7 @@ class AttrQuotes extends Rule {
         };
     }
     constructor(options) {
-        super({ ...defaults$r, ...options });
+        super({ ...defaults$s, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     setup() {
@@ -4738,12 +4738,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() {
@@ -4819,12 +4819,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() {
@@ -4980,12 +4980,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() {
@@ -5094,13 +5094,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 {
@@ -5263,12 +5263,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 {
@@ -5300,12 +5300,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 rulesHelper.CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -5371,14 +5371,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);
     }
@@ -5419,7 +5419,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:`,
                 "",
@@ -5963,46 +5963,125 @@ class EmptyTitle extends Rule {
     }
 }
 
-const CACHE_KEY = Symbol("form-elements");
+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 isRelevant$4(node) {
-    if (node.is("input")) {
-        /* ignore radiobuttons and checkboxes */
-        const type = node.getAttribute("type");
-        return !type || !type.valueMatches(["radio", "checkbox"], true);
+function allowSharedName(node, shared) {
+    const type = node.getAttribute("type");
+    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");
+        }
     }
-    return true;
 }
 class FormDupName extends Rule {
-    documentation() {
+    constructor(options) {
+        super({ ...defaults$k, ...options });
+    }
+    static schema() {
+        return {
+            allowArrayBrackets: {
+                type: "boolean",
+            },
+            shared: {
+                type: "array",
+                items: {
+                    enum: ["radio", "checkbox", "submit"],
+                },
+            },
+        };
+    }
+    documentation(context) {
         return {
-            description: "Each form control must have a unique name.",
+            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;
+            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, (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) {
+                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);
+        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,
@@ -6012,9 +6091,32 @@ class FormDupName extends Rule {
             });
         }
         else {
-            elements.add(name);
+            elements.set(name, {
+                array: false,
+            });
         }
     }
+    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,
+                kind: "duplicate",
+            };
+            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 +6132,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 Map();
+            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 Set();
-            form.cacheSet(CACHE_KEY, elements);
+            const elements = new Map();
+            form.cacheSet(SHARED_CACHE_KEY, elements);
             return elements;
         }
     }
@@ -11424,7 +11537,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.12.0";
+const version = "7.12.2";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";