html-validate 7.11.0 → 7.12.0

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;
 }
@@ -2041,6 +2061,11 @@ declare class NestedError extends Error {
  * @public
  */
 declare class UserError extends NestedError {
+    constructor(message: string, nested?: Error);
+    /**
+     * @public
+     */
+    prettyFormat(): string | undefined;
 }
 
 /**
@@ -2069,6 +2094,7 @@ declare class WrappedError<T> extends Error {
  * @public
  */
 declare class ConfigError extends UserError {
+    constructor(message: string, nested?: Error);
 }
 
 /**
@@ -2393,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

@@ -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",
@@ -1640,6 +1645,7 @@ class NestedError extends Error {
     constructor(message, nested) {
         super(message);
         Error.captureStackTrace(this, NestedError);
+        this.name = NestedError.name;
         if (nested && nested.stack) {
             this.stack += `\nCaused by: ${nested.stack}`;
         }
@@ -1650,6 +1656,48 @@ class NestedError extends Error {
  * @public
  */
 class UserError extends NestedError {
+    constructor(message, nested) {
+        super(message, nested);
+        Error.captureStackTrace(this, UserError);
+        this.name = UserError.name;
+    }
+    /**
+     * @public
+     */
+    /* istanbul ignore next: default implementation */
+    prettyFormat() {
+        return undefined;
+    }
+}
+
+/**
+ * @internal
+ */
+class InheritError extends UserError {
+    constructor({ tagName, inherit }) {
+        const message = `Element <${tagName}> cannot inherit from <${inherit}>: no such element`;
+        super(message);
+        Error.captureStackTrace(this, InheritError);
+        this.name = InheritError.name;
+        this.tagName = tagName;
+        this.inherit = inherit;
+        this.filename = null;
+    }
+    prettyFormat() {
+        const { message, tagName, inherit } = this;
+        const source = this.filename
+            ? ["", "This error occurred when loading element metadata from:", `"${this.filename}"`, ""]
+            : [""];
+        return [
+            message,
+            ...source,
+            "This usually occurs when the elements are defined in the wrong order, try one of the following:",
+            "",
+            `  - Ensure the spelling of "${inherit}" is correct.`,
+            `  - Ensure the file containing "${inherit}" is loaded before the file containing "${tagName}".`,
+            `  - Move the definition of "${inherit}" above the definition for "${tagName}".`,
+        ].join("\n");
+    }
 }
 
 function getSummary(schema, obj, errors) {
@@ -1839,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.",
@@ -1984,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: {
@@ -2073,6 +2135,9 @@ const definitions = {
 						items: {
 							type: "string"
 						}
+					},
+					{
+						type: "null"
 					}
 				]
 			}
@@ -2239,6 +2304,9 @@ function migrateAttributes(src) {
 function migrateElement(src) {
     const result = {
         ...src,
+        ...{
+            formAssociated: undefined,
+        },
         attributes: migrateAttributes(src),
         textContent: src.textContent,
     };
@@ -2249,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;
 }
 
@@ -2383,6 +2459,10 @@ class MetaTable {
             this.loadFromObject(data, filename);
         }
         catch (err) {
+            if (err instanceof InheritError) {
+                err.filename = filename;
+                throw err;
+            }
             if (err instanceof SchemaValidationError) {
                 throw err;
             }
@@ -2435,7 +2515,10 @@ class MetaTable {
             const name = entry.inherit;
             parent = this.elements[name];
             if (!parent) {
-                throw new UserError(`Element <${tagName}> cannot inherit from <${name}>: no such element`);
+                throw new InheritError({
+                    tagName,
+                    inherit: name,
+                });
             }
         }
         /* merge all sources together */
@@ -3404,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.
      */
@@ -3920,6 +4013,11 @@ class AriaLabelMisuse extends Rule {
  * @public
  */
 class ConfigError extends UserError {
+    constructor(message, nested) {
+        super(message, nested);
+        Error.captureStackTrace(this, ConfigError);
+        this.name = ConfigError.name;
+    }
 }
 
 const defaults$t = {
@@ -4809,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,
@@ -5833,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);
 }
@@ -5906,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));
     }
@@ -6440,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 {
@@ -8904,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,
@@ -9018,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"] }],
@@ -9081,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",
@@ -9910,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,
@@ -10741,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,
@@ -11169,7 +11392,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.11.0";
+const version = "7.12.0";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
@@ -11612,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