html-validate 7.11.1 → 7.12.1

package/dist/es/core.d.ts

@@ -343,6 +343,14 @@ declare abstract class Rule<ContextType = void, OptionsType = void> {
     isKeywordIgnored<T extends IncludeExcludeOptions>(this: {
         options: T;
     }, keyword: string, matcher?: (list: string[], it: string) => boolean): boolean;
+    /**
+     * 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: string): MetaElement | null;
     /**
      * Find all tags which has enabled given property.
      */
@@ -1002,13 +1010,16 @@ declare class Attribute {
     /**
      * Test attribute value.
      *
-     * @param pattern - Pattern to match value against. RegExp or a string (===)
+     * @param pattern - Pattern to match value against. Can be a RegExp, literal
+     * string or an array of strings (returns true if any value matches the
+     * array).
      * @param dynamicMatches - If true `DynamicValue` will always match, if false
      * it never matches.
      * @returns `true` if attribute value matches pattern.
      */
     valueMatches(pattern: RegExp, dynamicMatches?: boolean): boolean;
     valueMatches(pattern: string, dynamicMatches?: boolean): boolean;
+    valueMatches(pattern: string[], dynamicMatches?: boolean): boolean;
 }
 
 interface CSSStyleDeclaration {
@@ -1688,8 +1699,10 @@ declare enum TextContent {
  * description if there is an error.
  *
  * @public
+ * @param node - The node the attribute belongs to.
+ * @param attr - The current attribute being validated.
  */
-type MetaAttributeAllowedCallback = (node: HtmlElement) => string | null | undefined;
+type MetaAttributeAllowedCallback = (node: HtmlElement, attr: Attribute) => string | null | undefined;
 /**
  * @public
  */
@@ -1708,6 +1721,10 @@ interface DeprecatedElement {
     documentation?: string;
     source?: string;
 }
+interface FormAssociated {
+    /** Listed elements have a name attribute and is listed in the form and fieldset elements property. */
+    listed: boolean;
+}
 /**
  * @public
  */
@@ -1727,6 +1744,8 @@ interface MetaData {
     implicitClosed?: string[];
     scriptSupporting?: boolean;
     form?: boolean;
+    /** Mark element as a form-associated element */
+    formAssociated?: Partial<FormAssociated>;
     labelable?: boolean | PropertyExpression;
     deprecatedAttributes?: string[];
     requiredAttributes?: string[];
@@ -1743,7 +1762,7 @@ interface MetaData {
  * Properties listed here can be used to reverse search elements with the given
  * property enabled. See [[MetaTable.getTagsWithProperty]].
  */
-type MetaLookupableProperty = "metadata" | "flow" | "sectioning" | "heading" | "phrasing" | "embedded" | "interactive" | "deprecated" | "foreign" | "void" | "transparent" | "scriptSupporting" | "form" | "labelable";
+type MetaLookupableProperty = "metadata" | "flow" | "sectioning" | "heading" | "phrasing" | "embedded" | "interactive" | "deprecated" | "foreign" | "void" | "transparent" | "scriptSupporting" | "form" | "formAssociated" | "labelable";
 /**
  * Properties listed here can be copied (loaded) onto another element using
  * [[HtmlElement.loadMeta]].
@@ -1756,6 +1775,7 @@ declare const MetaCopyableProperty: Array<keyof MetaElement>;
  */
 interface MetaElement extends Omit<MetaData, "deprecatedAttributes" | "requiredAttributes"> {
     tagName: string;
+    formAssociated?: FormAssociated;
     attributes: Record<string, MetaAttribute>;
     textContent?: TextContent;
 }
@@ -2042,6 +2062,9 @@ declare class NestedError extends Error {
  */
 declare class UserError extends NestedError {
     constructor(message: string, nested?: Error);
+    /**
+     * @public
+     */
     prettyFormat(): string | undefined;
 }
 
@@ -2396,4 +2419,4 @@ interface AvailableFormatters {
 declare function getFormatter(name: keyof AvailableFormatters): Formatter;
 declare function getFormatter(name: string): Formatter | null;
 
-export { Event as $, AttributeData as A, Message as B, Config as C, DynamicValue as D, EventDump as E, Result as F, DeferredMessage as G, HtmlValidate as H, TransformContext as I, Transformer as J, TemplateExtractor as K, Location as L, MetaData as M, NodeClosed as N, Plugin as O, ProcessAttributeCallback as P, SchemaValidationPatch as Q, Rule as R, Severity as S, TextNode as T, UserError as U, definePlugin as V, WrappedError as W, Parser as X, ruleExists as Y, EventHandler as Z, EventCallback as _, ConfigData as a, ConfigReadyEvent as a0, SourceReadyEvent as a1, TokenEvent as a2, TagStartEvent as a3, TagOpenEvent as a4, TagEndEvent as a5, TagCloseEvent as a6, TagReadyEvent as a7, ElementReadyEvent as a8, AttributeEvent as a9, WhitespaceEvent as aa, ConditionalEvent as ab, DirectiveEvent as ac, DoctypeEvent as ad, DOMLoadEvent as ae, DOMReadyEvent as af, TriggerEventMap as ag, ListenEventMap as ah, FileSystemConfigLoader as ai, Formatter as aj, getFormatter as ak, compatibilityCheck as al, CompatibilityOptions as am, ConfigError as b, ConfigLoader as c, StaticConfigLoader as d, HtmlElement as e, CSSStyleDeclaration as f, TokenDump as g, SchemaValidationError as h, NestedError as i, MetaDataTable as j, MetaElement as k, MetaAttribute as l, MetaAttributeAllowedCallback as m, MetaTable as n, MetaCopyableProperty as o, presets as p, RuleConstructor as q, RuleDocumentation as r, Source as s, SourceHooks as t, ProcessElementCallback as u, version as v, ProcessElementContext as w, sliceLocation as x, Report as y, Reporter as z };
+export { EventCallback as $, AttributeData as A, Reporter as B, Config as C, DynamicValue as D, EventDump as E, Message as F, Result as G, HtmlValidate as H, DeferredMessage as I, TransformContext as J, Transformer as K, Location as L, MetaData as M, NodeClosed as N, TemplateExtractor as O, ProcessAttributeCallback as P, Plugin as Q, Rule as R, Severity as S, TextNode as T, UserError as U, SchemaValidationPatch as V, WrappedError as W, definePlugin as X, Parser as Y, ruleExists as Z, EventHandler as _, ConfigData as a, Event as a0, ConfigReadyEvent as a1, SourceReadyEvent as a2, TokenEvent as a3, TagStartEvent as a4, TagOpenEvent as a5, TagEndEvent as a6, TagCloseEvent as a7, TagReadyEvent as a8, ElementReadyEvent as a9, AttributeEvent as aa, WhitespaceEvent as ab, ConditionalEvent as ac, DirectiveEvent as ad, DoctypeEvent as ae, DOMLoadEvent as af, DOMReadyEvent as ag, TriggerEventMap as ah, ListenEventMap as ai, FileSystemConfigLoader as aj, Formatter as ak, getFormatter as al, compatibilityCheck as am, CompatibilityOptions as an, ConfigError as b, ConfigLoader as c, StaticConfigLoader as d, Attribute as e, HtmlElement as f, CSSStyleDeclaration as g, TokenDump as h, SchemaValidationError as i, NestedError as j, MetaDataTable as k, MetaElement as l, MetaAttribute as m, MetaAttributeAllowedCallback as n, MetaTable as o, presets as p, MetaCopyableProperty as q, RuleConstructor as r, RuleDocumentation as s, Source as t, SourceHooks as u, version as v, ProcessElementCallback as w, ProcessElementContext as x, sliceLocation as y, Report as z };

package/dist/es/core.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import betterAjvErrors from '@sidvind/better-ajv-errors';
-import { i as isKeywordIgnored, C as CaseStyle, n as naturalJoin, c as classifyNodeText, T as TextClassification, h as hasAltText, a as isHTMLHidden, b as isAriaHidden, d as hasAccessibleName, k as keywordPatternMatcher, e as inAccessibilityTree, f as hasAriaLabel } from './rules-helper.js';
+import { i as isKeywordIgnored, C as CaseStyle, n as naturalJoin, c as classifyNodeText, T as TextClassification, h as hasAltText, p as partition, a as isHTMLHidden, b as isAriaHidden, d as hasAccessibleName, k as keywordPatternMatcher, e as inAccessibilityTree, f as hasAriaLabel } from './rules-helper.js';
 import Ajv from 'ajv';
 import deepmerge from 'deepmerge';
 import * as espree from 'espree';
@@ -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,135 @@ class EmptyTitle extends Rule {
     }
 }
 
+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) {
+    const type = node.getAttribute("type");
+    return Boolean(type && type.valueMatches(["radio", "checkbox"], false));
+}
+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, _b;
+            const { document } = event;
+            const controls = document.querySelectorAll(selector);
+            const [sharedControls, uniqueControls] = 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)) {
+                    continue;
+                }
+                const form = (_b = control.closest("form")) !== null && _b !== void 0 ? _b : document.root;
+                this.validateSharedName(control, form, attr, name);
+            }
+        });
+    }
+    validateUniqueName(control, form, attr, name) {
+        const elements = this.getUniqueElements(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);
+        }
+    }
+    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);
+        });
+        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;
+    }
+    getUniqueElements(form) {
+        const existing = form.cacheGet(UNIQUE_CACHE_KEY);
+        if (existing) {
+            return existing;
+        }
+        else {
+            const elements = new Set();
+            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;
+        }
+    }
+}
+
 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 +6127,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 +6661,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 +9161,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 +9277,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 +9342,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 +10172,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 +11005,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 +11435,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.11.1";
+const version = "7.12.1";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
@@ -11666,5 +11878,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