@markuplint/rules 5.0.0-rc.2 → 5.0.0-rc.5

package/lib/{deprecated-attr → no-deprecated-attr}/index.js

@@ -1,13 +1,10 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that reports the use of deprecated or obsolete HTML attributes.
- *
- * Checks each attribute against the HTML spec and reports any that are
- * marked as deprecated or obsolete.
- */
 export default createRule({
     meta: meta,
+    // Deprecation data is sourced from MDN/BCD (factual, not a spec MUST/MUST
+    // NOT), unlike `no-obsolete-attr`'s HTML LS non-conforming-features list.
+    defaultSeverity: 'warning',
     async verify({ document, report, t }) {
         await document.walkOn('Attr', attr => {
             const attrSpecs = getAttrSpecs(attr.ownerElement, document.specs);
@@ -19,14 +16,13 @@ export default createRule({
             if (!attrSpec) {
                 return;
             }
-            if (attrSpec.deprecated || attrSpec.obsolete) {
-                const message = t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), attrSpec.obsolete ? 'obsolete' : 'deprecated');
+            if (attrSpec.deprecated) {
                 report({
                     scope: attr,
                     line: attr.nameNode?.startLine,
                     col: attr.nameNode?.startCol,
                     raw: attr.nameNode?.raw,
-                    message,
+                    message: t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'deprecated'),
                 });
             }
         });

package/lib/no-deprecated-attr/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "attributes";
+};
+export default _default;

package/lib/no-deprecated-attr/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'attributes',
+};

package/lib/no-deprecated-element/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/no-deprecated-element/index.js

@@ -0,0 +1,27 @@
+import { createRule, getSpec } from '@markuplint/ml-core';
+import meta from './meta.js';
+export default createRule({
+    meta: meta,
+    // Deprecation data is sourced from MDN/BCD (factual, not a spec MUST/MUST
+    // NOT), unlike `no-obsolete-element`'s HTML LS non-conforming-features list.
+    defaultSeverity: 'warning',
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (!(el.namespaceURI === 'http://www.w3.org/1999/xhtml' ||
+                el.namespaceURI === 'http://www.w3.org/2000/svg') ||
+                // Web components and authored elements (JSX/Vue/Svelte) reach this rule
+                // through `pretenders`: they masquerade as a known HTML element via
+                // `el.localName`, so the spec lookup below resolves correctly. See #3740.
+                (el.elementType !== 'html' && el.pretenderContext?.type !== 'pretender')) {
+                return;
+            }
+            const spec = getSpec(el, document.specs.specs);
+            if (spec && spec.deprecated) {
+                report({
+                    scope: el,
+                    message: t('{0} is {1:c}', t('the "{0*}" {1}', el.localName, 'element'), 'deprecated'),
+                });
+            }
+        });
+    },
+});

package/lib/no-deprecated-element/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "structure";
+};
+export default _default;

package/lib/no-deprecated-element/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'structure',
+};

package/lib/no-deprecated-role/index.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../wai-aria/types.js';
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/{wai-aria-deprecated-role → no-deprecated-role}/index.js

@@ -3,7 +3,6 @@ import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { checkingDeprecatedRole } from '../wai-aria/checkings/deprecated-role.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when a deprecated WAI-ARIA role is used. */
 export default createRule({
     meta,
     defaultSeverity: 'warning',

package/lib/no-disallowed-ancestor/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/no-disallowed-ancestor/index.js

@@ -0,0 +1,25 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+export default createRule({
+    meta: meta,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            const elSpec = document.specs.specs.find(s => s.name === el.localName);
+            const forbiddenAncestors = elSpec?.contentModel?.forbiddenAncestors;
+            if (!forbiddenAncestors || forbiddenAncestors.length === 0) {
+                return;
+            }
+            let ancestor = el.parentElement;
+            while (ancestor) {
+                if (forbiddenAncestors.some(selector => ancestor.matches(selector))) {
+                    report({
+                        scope: el,
+                        message: t('{0} must not appear as a descendant of {1}', t('the "{0}" {1}', el.localName, 'element'), t('the "{0}" {1}', ancestor.localName, 'element')),
+                    });
+                    break;
+                }
+                ancestor = ancestor.parentElement;
+            }
+        });
+    },
+});

package/lib/no-disallowed-ancestor/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "structure";
+};
+export default _default;

package/lib/no-disallowed-ancestor/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'structure',
+};

package/lib/no-disallowed-attr/index.d.ts

@@ -0,0 +1,28 @@
+import type { AttributeType } from '@markuplint/ml-spec';
+import type { Pattern } from '@markuplint/types';
+/**
+ * Configuration options for the `no-disallowed-attr` rule.
+ */
+type Option = {
+    /**
+     * Attribute names to treat as known and allowed, beyond what the spec
+     * defines. Shares its shape with `no-unknown-attr`'s option of the same
+     * name — see that rule for the full description.
+     *
+     * @since 3.7.0
+     */
+    allowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
+    /** Attribute name prefix(es) to ignore during validation. */
+    ignoreAttrNamePrefix?: string | string[];
+};
+/**
+ * Describes a single attribute with its name and expected value constraint.
+ */
+type Attr = {
+    /** The attribute name. */
+    name: string;
+    /** The expected attribute value type or validation rule. */
+    value: AttributeType | Pattern;
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
+export default _default;

package/lib/no-disallowed-attr/index.js

@@ -0,0 +1,77 @@
+import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import { resolveAttrEligibility } from '../attr-eligibility.js';
+import meta from './meta.js';
+function allowedNames(allowAttrs) {
+    if (!allowAttrs) {
+        return new Set();
+    }
+    if (Array.isArray(allowAttrs)) {
+        return new Set(allowAttrs.map(a => (typeof a === 'string' ? a : a.name)));
+    }
+    return new Set(Object.keys(allowAttrs));
+}
+export default createRule({
+    meta: meta,
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        await document.walkOn('Attr', attr => {
+            if (attr.isDirective) {
+                return;
+            }
+            const name = attr.name;
+            const attrName = attr.nameNode;
+            // https://html.spec.whatwg.org/multipage/custom-elements.html#attr-is
+            // "The is attribute must not be specified on an autonomous custom element"
+            if (name === 'is' && attr.ownerElement.elementType === 'web-component') {
+                report({
+                    scope: attr,
+                    line: attrName?.startLine,
+                    col: attrName?.startCol,
+                    raw: attrName?.raw,
+                    message: t('The "{0}" attribute must not be specified on an autonomous custom element', 'is'),
+                });
+                return;
+            }
+            if (attr.rule.options.ignoreAttrNamePrefix != null) {
+                const prefixes = Array.isArray(attr.rule.options.ignoreAttrNamePrefix)
+                    ? attr.rule.options.ignoreAttrNamePrefix
+                    : [attr.rule.options.ignoreAttrNamePrefix];
+                if (prefixes.some(prefix => name.indexOf(prefix) === 0)) {
+                    return;
+                }
+            }
+            if (allowedNames(attr.rule.options.allowAttrs).has(name)) {
+                return;
+            }
+            if (attr.ownerElement.elementType !== 'html') {
+                return;
+            }
+            const attrSpecs = getAttrSpecs(attr.ownerElement, document.specs);
+            if (!attrSpecs) {
+                return;
+            }
+            const eligibility = resolveAttrEligibility(name, attr.ownerElement, attrSpecs);
+            if (eligibility.status === 'no-use') {
+                report({
+                    scope: attr,
+                    message: t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed'),
+                });
+                return;
+            }
+            if (eligibility.status !== 'condition-not-met') {
+                return;
+            }
+            const spec = getSpec(attr.ownerElement, document.specs.specs);
+            if (spec?.possibleToAddProperties) {
+                return;
+            }
+            report({
+                scope: attr,
+                message: t('{0} is {1}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed'),
+                line: attrName?.startLine,
+                col: attrName?.startCol,
+                raw: attrName?.raw,
+            });
+        });
+    },
+});

package/lib/no-disallowed-attr/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "attributes";
+};
+export default _default;

package/lib/no-disallowed-attr/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'attributes',
+};

package/lib/no-duplicate-attr/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/{attr-duplication → no-duplicate-attr}/index.js

@@ -1,13 +1,6 @@
 import { createRule } from '@markuplint/ml-core';
 import { removeAttr } from '../helpers.js';
 import meta from './meta.js';
-/**
- * Rule that checks for duplicate attributes on the same element.
- *
- * Walks all elements and reports when two or more attributes share the same
- * name (case-insensitive for HTML elements). Attributes marked as duplicatable
- * (e.g., template-engine directives) are excluded from this check.
- */
 export default createRule({
     meta: meta,
     async verify({ document, report, t }) {

package/lib/no-duplicate-attr/meta.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    readonly category: "syntax";
+    readonly fixable: true;
+    readonly mirrorsParseErrorCodes: readonly ["duplicate-attribute"];
+};
+export default _default;

package/lib/no-duplicate-attr/meta.js

@@ -0,0 +1,10 @@
+export default {
+    category: 'syntax',
+    fixable: true,
+    // This rule's detection is a superset of parse5's `duplicate-attribute`
+    // event: parse5 only fires on HTML elements (case-insensitive), while
+    // this rule also covers JSX / SVG / authored components. When the rule
+    // is active, ml-core dedupes the built-in parse-error channel so users
+    // don't see two violations for the same duplicate.
+    mirrorsParseErrorCodes: ['duplicate-attribute'],
+};

package/lib/no-duplicate-autofocus/index.d.ts

@@ -1,7 +1,2 @@
-/**
- * Ensures no more than one element in a document has the `autofocus` attribute.
- *
- * @see https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
 export default _default;

package/lib/no-duplicate-autofocus/index.js

@@ -1,10 +1,18 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
- * Ensures no more than one element in a document has the `autofocus` attribute.
+ * The HTML Living Standard scopes autofocus uniqueness to the "nearest ancestor
+ * autofocus scoping root element" — the element itself if it is a `dialog` or
+ * has a `popover` attribute, otherwise the nearest such ancestor, otherwise the
+ * document as a whole. Two `autofocus` elements only conflict when they share
+ * the same scoping root; two `dialog`/`popover` elements can each carry their
+ * own `autofocus` target without conflict.
  *
  * @see https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute
  */
+function getAutofocusScopingRoot(el) {
+    return el.closest('dialog, [popover]');
+}
 export default createRule({
     meta: meta,
     defaultValue: true,
@@ -17,11 +25,17 @@ export default createRule({
                 autofocusElements.push(el);
             }
         });
-        for (const el of autofocusElements.slice(1)) {
-            report({
-                scope: el,
-                message: t('The "{0}" attribute must be unique in the document', 'autofocus'),
-            });
+        const seenScopingRoots = new Set();
+        for (const el of autofocusElements) {
+            const scopingRoot = getAutofocusScopingRoot(el);
+            if (seenScopingRoots.has(scopingRoot)) {
+                report({
+                    scope: el,
+                    message: t('The "{0}" attribute must be unique in the document', 'autofocus'),
+                });
+                continue;
+            }
+            seenScopingRoots.add(scopingRoot);
         }
     },
 });

package/lib/no-duplicate-autofocus/meta.d.ts

@@ -1,4 +1,4 @@
 declare const _default: {
-    readonly category: "validation";
+    readonly category: "attributes";
 };
 export default _default;

package/lib/no-duplicate-autofocus/meta.js

@@ -1,3 +1,3 @@
 export default {
-    category: 'validation',
+    category: 'attributes',
 };

package/lib/no-duplicate-dt/index.d.ts

@@ -1,8 +1,2 @@
-/**
- * Rule that validates there are no duplicate `<dt>` elements within a `<dl>`.
- *
- * Iterates through each definition list and checks that no two `<dt>` elements
- * (direct children or wrapped in `<div>`) share the same text content.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/no-duplicate-dt/index.js

@@ -1,13 +1,8 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that validates there are no duplicate `<dt>` elements within a `<dl>`.
- *
- * Iterates through each definition list and checks that no two `<dt>` elements
- * (direct children or wrapped in `<div>`) share the same text content.
- */
 export default createRule({
     meta: meta,
+    defaultSeverity: 'warning',
     verify({ document, report, t }) {
         const dlList = [...document.querySelectorAll('dl')];
         for (const dl of dlList) {

package/lib/no-duplicate-dt/meta.d.ts

@@ -1,5 +1,4 @@
-/** Rule metadata for the `no-duplicate-dt` rule, categorized as validation. */
 declare const _default: {
-    readonly category: "validation";
+    readonly category: "structure";
 };
 export default _default;

package/lib/no-duplicate-dt/meta.js

@@ -1,4 +1,3 @@
-/** Rule metadata for the `no-duplicate-dt` rule, categorized as validation. */
 export default {
-    category: 'validation',
+    category: 'structure',
 };

package/lib/no-duplicate-h1/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configuration options for the `no-duplicate-h1` rule.
+ */
+export interface Options {
+    /** Whether to apply this rule in document fragments (components, partials). */
+    'in-document-fragment': boolean;
+}
+/**
+ * Split from the former `required-h1` rule (#3989): the duplicate-`<h1>`
+ * half. Based on WCAG's Techniques H42 for Success Criterion 1.3.1 — a
+ * non-normative technique, not the criterion itself, so this rule's default
+ * severity is `warning`. The former rule's `expected-once` option gated this
+ * check; disabling this rule entirely is how to opt out now.
+ *
+ * @see https://www.w3.org/WAI/WCAG21/Techniques/html/H42
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/no-duplicate-h1/index.js

@@ -0,0 +1,41 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * Split from the former `required-h1` rule (#3989): the duplicate-`<h1>`
+ * half. Based on WCAG's Techniques H42 for Success Criterion 1.3.1 — a
+ * non-normative technique, not the criterion itself, so this rule's default
+ * severity is `warning`. The former rule's `expected-once` option gated this
+ * check; disabling this rule entirely is how to opt out now.
+ *
+ * @see https://www.w3.org/WAI/WCAG21/Techniques/html/H42
+ */
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {
+        'in-document-fragment': false,
+    },
+    async verify({ document, report, t }) {
+        const h1Stack = [];
+        if (document.nodeList.length === 0) {
+            return;
+        }
+        if (!document.rule.options['in-document-fragment'] && document.isFragment) {
+            return;
+        }
+        await document.walkOn('Element', node => {
+            if (node.nodeName.toLowerCase() === 'h1') {
+                h1Stack.push(node);
+            }
+        });
+        if (h1Stack.length > 1 && h1Stack[1]) {
+            const message = t('{0} is {1:c}', t('the "{0*}" {1}', 'h1', 'element'), 'duplicated');
+            report({
+                message,
+                line: h1Stack[1].startLine,
+                col: h1Stack[1].startCol,
+                raw: h1Stack[1].raw,
+            });
+        }
+    },
+});

package/lib/no-duplicate-h1/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/no-duplicate-h1/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'a11y',
+};

package/lib/no-duplicate-id/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/{id-duplication → no-duplicate-id}/index.js

@@ -1,12 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that checks for duplicate `id` attribute values within a document.
- *
- * Walks all elements and collects `id` values, reporting any that have
- * already been seen. Dynamic values and directive attributes are excluded
- * from the check.
- */
 export default createRule({
     meta: meta,
     async verify({ document, report, t }) {

package/lib/no-duplicate-id/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "references";
+};
+export default _default;

package/lib/no-duplicate-id/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'references',
+};

package/lib/no-duplicate-sibling-attr/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/no-duplicate-sibling-attr/index.js

@@ -0,0 +1,35 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+export default createRule({
+    meta: meta,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            const elSpec = document.specs.specs.find(s => s.name === el.localName);
+            const uniqueAttrs = elSpec?.contentModel?.uniqueAttrs;
+            if (!uniqueAttrs || uniqueAttrs.length === 0) {
+                return;
+            }
+            for (const attrName of uniqueAttrs) {
+                if (!el.hasAttribute(attrName)) {
+                    continue;
+                }
+                const parent = el.parentElement;
+                if (!parent) {
+                    continue;
+                }
+                // Only report on the second (and subsequent) element that has the attribute
+                const precedingSiblings = [...parent.children];
+                const elIndex = precedingSiblings.indexOf(el);
+                const hasPrecedingDuplicate = precedingSiblings
+                    .slice(0, elIndex)
+                    .some(child => child.localName === el.localName && child.hasAttribute(attrName));
+                if (hasPrecedingDuplicate) {
+                    report({
+                        scope: el,
+                        message: t('The "{0}" attribute must not appear on more than one "{1}" element within the same parent', attrName, el.localName),
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/no-duplicate-sibling-attr/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "structure";
+};
+export default _default;

package/lib/no-duplicate-sibling-attr/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'structure',
+};

package/lib/no-duplicate-visible-main/index.d.ts

@@ -1,5 +1,4 @@
 /**
- * Ensures no more than one visible `<main>` element exists in a document.
  * A `<main>` element with the `hidden` attribute is not considered visible.
  *
  * @see https://html.spec.whatwg.org/multipage/grouping-content.html#the-main-element

package/lib/no-duplicate-visible-main/index.js

@@ -1,7 +1,6 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
- * Ensures no more than one visible `<main>` element exists in a document.
  * A `<main>` element with the `hidden` attribute is not considered visible.
  *
  * @see https://html.spec.whatwg.org/multipage/grouping-content.html#the-main-element

package/lib/no-duplicate-visible-main/meta.d.ts

@@ -1,4 +1,4 @@
 declare const _default: {
-    readonly category: "validation";
+    readonly category: "structure";
 };
 export default _default;

package/lib/no-duplicate-visible-main/meta.js

@@ -1,3 +1,3 @@
 export default {
-    category: 'validation',
+    category: 'structure',
 };

package/lib/no-empty-palpable-content/index.d.ts

@@ -7,13 +7,5 @@ type Options = {
     /** Whether to ignore elements marked with `aria-busy="true"`. */
     ignoreIfAriaBusy?: boolean;
 };
-/**
- * Rule that warns when palpable content elements are empty.
- *
- * Palpable content elements are expected to have visible or meaningful content.
- * This rule reports elements that contain only whitespace text nodes, while
- * excluding elements that are naturally empty (e.g., `<textarea>`, `<video>`)
- * or have a nothing content model.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/no-empty-palpable-content/index.js

@@ -15,14 +15,6 @@ const allowedElements = new Set([
     'video',
     'img',
 ]);
-/**
- * Rule that warns when palpable content elements are empty.
- *
- * Palpable content elements are expected to have visible or meaningful content.
- * This rule reports elements that contain only whitespace text nodes, while
- * excluding elements that are naturally empty (e.g., `<textarea>`, `<video>`)
- * or have a nothing content model.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-empty-palpable-content/meta.d.ts

@@ -1,5 +1,4 @@
-/** Rule metadata for the `no-empty-palpable-content` rule, categorized as validation. */
 declare const _default: {
-    readonly category: "validation";
+    readonly category: "structure";
 };
 export default _default;

package/lib/no-empty-palpable-content/meta.js

@@ -1,4 +1,3 @@
-/** Rule metadata for the `no-empty-palpable-content` rule, categorized as validation. */
 export default {
-    category: 'validation',
+    category: 'structure',
 };