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

package/lib/{correct-aspect-ratio → no-mismatched-aspect-ratio}/index.js

@@ -1,9 +1,16 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
 import { getImageDimensions } from './resolve-image-size.js';
+/**
+ * HTML LS §4.8.17 Dimension attributes: "the specified height and width must
+ * match the dimensions of the intrinsic aspect ratio". `width`/`height`
+ * attributes are integers, so an image whose intrinsic ratio doesn't divide
+ * evenly can never have an exact integer match — a half-pixel tolerance
+ * absorbs that unavoidable rounding without accepting a genuinely wrong ratio.
+ */
+const TOLERANCE_PX = 0.5;
 export default createRule({
     meta: meta,
-    defaultSeverity: 'warning',
     defaultOptions: {},
     async verify({ document, report }) {
         await document.walkOn('Element', async (el) => {
@@ -61,8 +68,11 @@ export default createRule({
                 return;
             }
             const { width: actualWidth, height: actualHeight } = dimensions;
-            // Cross-multiplication comparison to avoid floating-point errors
-            if (attrWidth * actualHeight !== attrHeight * actualWidth) {
+            // Cross-multiplication keeps the comparison in integer space; dividing by
+            // actualWidth expresses the mismatch in height-pixel-equivalent units so it
+            // can be checked against the pixel tolerance.
+            const mismatchPx = Math.abs(attrWidth * actualHeight - attrHeight * actualWidth) / actualWidth;
+            if (mismatchPx > TOLERANCE_PX) {
                 report({
                     scope: el,
                     message: `The aspect ratio of the image (${actualWidth}:${actualHeight}) does not match the width/height attributes (${widthStr}:${heightStr})`,

package/lib/no-mismatched-aspect-ratio/meta.d.ts

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

package/lib/no-mismatched-aspect-ratio/meta.js

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

package/lib/{correct-aspect-ratio → no-mismatched-aspect-ratio}/resolve-image-size.js

@@ -126,7 +126,12 @@ export async function getImageDimensions(src, documentRoot, documentFilename) {
         return null;
     }
     await loadCacheFromDisk();
-    // Get file size for cache key
+    // Get file size for cache key. Deliberately treats every failure class the
+    // same (missing file, permission denied, I/O error, etc.) as "can't check
+    // this image" rather than a lint-worthy violation — a filesystem problem
+    // unrelated to markup correctness shouldn't fail the lint run, and this
+    // rule has no way to distinguish "the author has a typo in src" (already
+    // the common, expected case) from a transient/environmental read failure.
     let fileSize;
     try {
         const fileStat = await stat(absolutePath);
@@ -140,7 +145,8 @@ export async function getImageDimensions(src, documentRoot, documentFilename) {
     if (cached) {
         return cached;
     }
-    // Read and measure the image
+    // Read and measure the image. Same rationale as the `stat` catch above:
+    // any read failure means this rule can't check the image, not a violation.
     let buffer;
     try {
         buffer = await readFile(absolutePath);

package/lib/no-mixed-srcset-descriptors/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HTML LS § Srcset attributes: every candidate in a `srcset` must use the
+ * same kind of descriptor — all width (`w`) or all pixel density (`x`,
+ * including the implied `1x` of a descriptor-less candidate). Split out of
+ * the former `srcset-sizes-constraint` rule's Check 2.
+ *
+ * Overlaps with the `Srcset` type validator `no-invalid-attr-value` uses for
+ * the same attribute: that rule validates syntax, this one validates the
+ * inter-descriptor constraint, and both may fire on the same mixed value.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-mixed-srcset-descriptors/index.js

@@ -0,0 +1,47 @@
+import { createRule } from '@markuplint/ml-core';
+import { parseSrcset } from '../srcset-sizes-constraint/parse-srcset.js';
+import meta from './meta.js';
+/**
+ * HTML LS § Srcset attributes: every candidate in a `srcset` must use the
+ * same kind of descriptor — all width (`w`) or all pixel density (`x`,
+ * including the implied `1x` of a descriptor-less candidate). Split out of
+ * the former `srcset-sizes-constraint` rule's Check 2.
+ *
+ * Overlaps with the `Srcset` type validator `no-invalid-attr-value` uses for
+ * the same attribute: that rule validates syntax, this one validates the
+ * inter-descriptor constraint, and both may fire on the same mixed value.
+ */
+export default createRule({
+    meta,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const localName = el.localName;
+            // Only check img and source (inside picture) elements
+            if (localName !== 'img' && localName !== 'source') {
+                return;
+            }
+            // source is only relevant inside <picture>
+            if (localName === 'source' && el.parentElement?.localName !== 'picture') {
+                return;
+            }
+            // Skip if element has spread attributes (dynamic props)
+            if (el.hasSpreadAttr) {
+                return;
+            }
+            const srcsetAttr = el.getAttributeNode('srcset');
+            if (!srcsetAttr || srcsetAttr.isDynamicValue) {
+                return;
+            }
+            const parsed = parseSrcset(srcsetAttr.value);
+            if (parsed.hasWidth && (parsed.hasDensity || parsed.hasImplied)) {
+                report({
+                    scope: el,
+                    line: srcsetAttr.valueNode?.startLine,
+                    col: srcsetAttr.valueNode?.startCol,
+                    raw: srcsetAttr.valueNode?.raw,
+                    message: 'The "srcset" attribute must not mix width and pixel density descriptors',
+                });
+            }
+        });
+    },
+});

package/lib/no-mixed-srcset-descriptors/meta.d.ts

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

package/lib/no-mixed-srcset-descriptors/meta.js

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

package/lib/no-nested-top-level-landmark/index.d.ts

@@ -0,0 +1,10 @@
+import type { Roles } from '../landmark-roles/roles.js';
+/**
+ * Configuration options for the `no-nested-top-level-landmark` rule.
+ */
+type Options = {
+    /** Landmark roles to exclude from validation. */
+    ignoreRoles: Roles[];
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/no-nested-top-level-landmark/index.js

@@ -0,0 +1,52 @@
+import { createRule } from '@markuplint/ml-core';
+import { computeLandmarkRoles, landmarkRoleElementUUIDList } from '../landmark-roles/roles.js';
+import meta from './meta.js';
+/**
+ * Roles this rule requires to be top-level landmarks — not nested inside any
+ * other landmark.
+ *
+ * Split from the former `landmark-roles` rule (#3989), unchanged: APG's
+ * Landmark Regions practice also requires `complementary` to be top-level,
+ * but this rule deliberately does not check it. `<aside>`'s implicit role is
+ * conditional under ARIA 1.3 (v5's default version) — nested inside certain
+ * sectioning ancestors it demotes to `generic`, not `complementary` — and
+ * this rule's selector-based detection (`landmark-roles/roles.ts`) has no way
+ * to tell the two apart, so checking `complementary` here would produce
+ * false positives for legitimately generic asides. See the v4→v5 ARIA
+ * migration guide's "`<aside>` conditional role mapping" section for the
+ * full history of that decision.
+ *
+ * @see https://www.w3.org/WAI/ARIA/apg/practices/landmark-regions/
+ */
+const topLevelRoles = ['banner', 'main', 'contentinfo'];
+export default createRule({
+    meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {
+        ignoreRoles: [],
+    },
+    verify({ document, report, t }) {
+        if (document.isFragment) {
+            return;
+        }
+        const roles = computeLandmarkRoles(document);
+        const uuidList = landmarkRoleElementUUIDList(roles);
+        for (const role of topLevelRoles) {
+            const elements = roles[role];
+            for (const el of elements) {
+                if (el.rule.disabled) {
+                    continue;
+                }
+                if (el.rule.options.ignoreRoles?.includes(role)) {
+                    continue;
+                }
+                if (el.isDescendantByUUIDList(uuidList)) {
+                    report({
+                        scope: el,
+                        message: t('{0} should be {1}', t('the "{0*}" {1}', role, 'role'), 'top level'),
+                    });
+                }
+            }
+        }
+    },
+});

package/lib/no-nested-top-level-landmark/meta.d.ts

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

package/lib/no-nested-top-level-landmark/meta.js

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

package/lib/no-nonstandard-features/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Options for the `no-nonstandard-features` rule.
+ */
+type Options = {
+    /** Features to ignore. Element name ("dialog") or attribute pattern ("input[list]"). */
+    readonly ignoreFeatures?: readonly string[];
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/no-nonstandard-features/index.js

@@ -0,0 +1,53 @@
+import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import meta from './meta.js';
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        const options = document.rule.options;
+        const ignoreFeatures = new Set(options.ignoreFeatures);
+        await document.walkOn('Element', el => {
+            // Web components and authored elements (JSX/Vue/Svelte) reach this rule
+            // via `pretenders`: they masquerade as a known HTML element on `el.localName`,
+            // so spec lookups below resolve correctly. See #3740.
+            if (el.namespaceURI !== 'http://www.w3.org/1999/xhtml' ||
+                (el.elementType !== 'html' && el.pretenderContext?.type !== 'pretender')) {
+                return;
+            }
+            const elName = el.localName;
+            const elOptions = el.rule.options;
+            const elIgnoreFeatures = new Set(elOptions.ignoreFeatures ?? ignoreFeatures);
+            if (!elIgnoreFeatures.has(elName)) {
+                const spec = getSpec(el, document.specs.specs);
+                if (spec?.nonStandard) {
+                    report({
+                        scope: el,
+                        message: t('{0} is {1:c}', t('the "{0*}" {1}', elName, 'element'), 'non-standard'),
+                    });
+                }
+            }
+            const attrSpecs = getAttrSpecs(el, document.specs);
+            for (const attr of el.attributes) {
+                if (attr.isDirective) {
+                    continue;
+                }
+                const attrName = attr.name;
+                const ignoreKey = `${elName}[${attrName}]`;
+                if (elIgnoreFeatures.has(ignoreKey)) {
+                    continue;
+                }
+                const attrSpec = attrSpecs?.find(s => s.name === attrName);
+                if (attrSpec?.nonStandard) {
+                    report({
+                        scope: attr,
+                        line: attr.nameNode?.startLine,
+                        col: attr.nameNode?.startCol,
+                        raw: attr.nameNode?.raw,
+                        message: t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'attribute'), 'non-standard'),
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/no-nonstandard-features/meta.d.ts

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

package/lib/no-nonstandard-features/meta.js

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

package/lib/no-obsolete-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-obsolete-attr/index.js

@@ -0,0 +1,27 @@
+import { createRule, getAttrSpecs } from '@markuplint/ml-core';
+import meta from './meta.js';
+export default createRule({
+    meta: meta,
+    async verify({ document, report, t }) {
+        await document.walkOn('Attr', attr => {
+            const attrSpecs = getAttrSpecs(attr.ownerElement, document.specs);
+            if (!attrSpecs) {
+                return;
+            }
+            const name = attr.name;
+            const attrSpec = attrSpecs.find(item => item.name === name);
+            if (!attrSpec) {
+                return;
+            }
+            if (attrSpec.obsolete) {
+                report({
+                    scope: attr,
+                    line: attr.nameNode?.startLine,
+                    col: attr.nameNode?.startCol,
+                    raw: attr.nameNode?.raw,
+                    message: t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'obsolete'),
+                });
+            }
+        });
+    },
+});

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

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

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

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

package/lib/no-obsolete-doctype/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/{doctype → no-obsolete-doctype}/index.js

@@ -1,31 +1,24 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
- * Rule that validates the presence and correctness of the document's DOCTYPE
- * declaration.
- *
- * Reports an error when no DOCTYPE is found (skipped for document fragments)
- * and when an obsolete DOCTYPE (one with a public or system identifier) is
- * declared.
+ * HTML LS §13.1.1: the "force-quirks flag" doctype-parsing algorithm has no
+ * exception for this string, but §the-initial-insertion-mode / the DOCTYPE
+ * grammar explicitly permits `<!DOCTYPE html SYSTEM "about:legacy-compat">`
+ * as the one conforming legacy-string doctype, used to keep a document
+ * shareable with old parsers that require a system identifier.
  */
+const LEGACY_COMPAT_SYSTEM_ID = 'about:legacy-compat';
 export default createRule({
     meta: meta,
-    defaultValue: 'always',
-    defaultOptions: {
-        denyObsoleteType: true,
-    },
     verify({ document, report, t }) {
         if (document.isFragment) {
             return;
         }
         const doctype = document.doctype;
         if (!doctype) {
-            report({
-                message: t('Require {0}', 'doctype'),
-                line: 1,
-                col: 1,
-                raw: '',
-            });
+            return;
+        }
+        if (!doctype.publicId && doctype.systemId === LEGACY_COMPAT_SYSTEM_ID) {
             return;
         }
         if ((doctype.name.toLowerCase() === 'html' && doctype.publicId) || doctype.systemId) {

package/lib/no-obsolete-doctype/meta.d.ts

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

package/lib/no-obsolete-doctype/meta.js

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

package/lib/no-obsolete-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/{deprecated-element → no-obsolete-element}/index.js

@@ -1,26 +1,22 @@
 import { createRule, getSpec } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that reports the use of deprecated or obsolete HTML elements.
- *
- * Walks HTML and SVG elements and checks their spec status. Reports any
- * element that is marked as deprecated or obsolete in the HTML specification.
- */
 export default createRule({
     meta: meta,
     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') ||
-                el.elementType !== 'html') {
+                // 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.obsolete != null || spec.deprecated)) {
-                const message = t('{0} is {1:c}', t('the "{0*}" {1}', el.localName, 'element'), spec.deprecated ? 'deprecated' : 'obsolete');
+            if (spec && spec.obsolete != null) {
                 report({
                     scope: el,
-                    message,
+                    message: t('{0} is {1:c}', t('the "{0*}" {1}', el.localName, 'element'), 'obsolete'),
                 });
             }
         });

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

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

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

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

package/lib/no-orphaned-end-tag/index.d.ts

@@ -1,9 +1,2 @@
-/**
- * Rule that detects orphaned end tags with no matching start tag.
- *
- * Scans text nodes and reports any that originated from invalid (bogus) AST
- * nodes, which indicates a stray end tag that the parser could not match
- * to an opening element.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
 export default _default;

package/lib/no-orphaned-end-tag/index.js

@@ -1,12 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that detects orphaned end tags with no matching start tag.
- *
- * Scans text nodes and reports any that originated from invalid (bogus) AST
- * nodes, which indicates a stray end tag that the parser could not match
- * to an opening element.
- */
 export default createRule({
     meta,
     async verify({ document, report, t }) {

package/lib/no-orphaned-end-tag/meta.d.ts

@@ -1,6 +1,6 @@
-/** Rule metadata for `no-orphaned-end-tag`: categorized as a validation rule. */
 declare const _default: {
-    readonly category: "validation";
+    readonly category: "syntax";
     readonly fixable: true;
+    readonly mirrorsParseErrorCodes: readonly ["end-tag-without-matching-open-element"];
 };
 export default _default;

package/lib/no-orphaned-end-tag/meta.js

@@ -1,5 +1,8 @@
-/** Rule metadata for `no-orphaned-end-tag`: categorized as a validation rule. */
 export default {
-    category: 'validation',
+    category: 'syntax',
     fixable: true,
+    // Mirrors parse5's `end-tag-without-matching-open-element`. This rule
+    // reads `text.isBogus` (set by parser-utils from parse5's tree-construction
+    // step) so the detection is by definition aligned with parse5's judgement.
+    mirrorsParseErrorCodes: ['end-tag-without-matching-open-element'],
 };

package/lib/no-prohibited-naming/index.d.ts

@@ -0,0 +1,8 @@
+import type { Options } from '../wai-aria/types.js';
+/**
+ * Split from the former `wai-aria-disallowed-props` rule (#3989): the naming-
+ * prohibition constraint alone. See `checkingProhibitedNaming`'s JSDoc for the
+ * full spec citation.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/no-prohibited-naming/index.js

@@ -0,0 +1,36 @@
+import { createRule, getComputedRole, ariaSpecs, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingProhibitedNaming } from '../wai-aria/checkings/prohibited-naming.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+/**
+ * Split from the former `wai-aria-disallowed-props` rule (#3989): the naming-
+ * prohibition constraint alone. See `checkingProhibitedNaming`'s JSDoc for the
+ * full spec citation.
+ */
+export default createRule({
+    meta,
+    defaultOptions,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const elSpec = getSpec(el, document.specs.specs);
+            // Autonomous custom elements have no spec.<el>.jsonc entry. They
+            // still accept aria-* per the platform, so do not skip them here —
+            // `checkingProhibitedNaming` enforces the ARIA in HTML §4.4 naming
+            // prohibition for unnamed-role custom elements.
+            if (!elSpec && el.elementType !== 'web-component')
+                return;
+            if (elSpec && !elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            if (propAttrs.length === 0)
+                return;
+            const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+            const computed = getComputedRole(document.specs, el, ariaVersion);
+            const { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
+            for (const attr of propAttrs) {
+                report(checkingProhibitedNaming({ attr, role: computed.role, propSpecs }));
+            }
+        });
+    },
+});

package/lib/no-prohibited-naming/meta.d.ts

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

package/lib/no-prohibited-naming/meta.js

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

package/lib/{use-list → no-pseudo-list}/index.d.ts

@@ -1,7 +1,7 @@
 /** An array of characters recognized as bullet-like symbols indicating list items. */
 type Bullets = readonly string[];
 /**
- * Configuration options for the use-list rule.
+ * Configuration options for the no-pseudo-list rule.
  */
 type Options = {
     /** Bullet characters that require a space after them to be considered list items. */
@@ -15,12 +15,5 @@ type Options = {
     /** Whether to report text nodes preceded by a preprocessor block. */
     prevCodeBlock?: boolean;
 };
-/**
- * Rule that suggests using `<li>` elements instead of text with bullet characters.
- *
- * Detects text nodes that start with bullet-like characters (Unicode bullets,
- * markdown-style dashes/asterisks, etc.) and recommends converting them into
- * proper list markup using `<li>` elements.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<Bullets, Options>>;
 export default _default;

package/lib/{use-list → no-pseudo-list}/index.js

@@ -1,13 +1,6 @@
 import { createRule } from '@markuplint/ml-core';
 import { decodeEntities } from '@markuplint/shared';
 import meta from './meta.js';
-/**
- * Rule that suggests using `<li>` elements instead of text with bullet characters.
- *
- * Detects text nodes that start with bullet-like characters (Unicode bullets,
- * markdown-style dashes/asterisks, etc.) and recommends converting them into
- * proper list markup using `<li>` elements.
- */
 export default createRule({
     meta: meta,
     defaultValue: [

package/lib/no-pseudo-list/meta.d.ts

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

package/lib/no-pseudo-list/meta.js

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

package/lib/{redundant-accessible-name → no-redundant-accessible-name}/index.d.ts

@@ -1,8 +1,4 @@
 import type { RuleConfigValue } from '@markuplint/ml-core';
-/**
- * Rule that detects elements with multiple accessible name sources
- * where a higher-priority source overrides a lower-priority one.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RuleConfigValue, {
     checkTitleFallback: boolean;
     checkPlaceholderFallback: boolean;

package/lib/{redundant-accessible-name → no-redundant-accessible-name}/index.js

@@ -2,10 +2,6 @@ import { createRule, getComputedRole } from '@markuplint/ml-core';
 import { ARIA_RECOMMENDED_VERSION, isExposed } from '@markuplint/ml-spec';
 import { accnameMayBeMutable, getOwnedLabel } from '../helpers.js';
 import meta from './meta.js';
-/**
- * Rule that detects elements with multiple accessible name sources
- * where a higher-priority source overrides a lower-priority one.
- */
 export default createRule({
     meta,
     defaultSeverity: 'warning',

package/lib/no-redundant-accessible-name/meta.d.ts

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

package/lib/no-redundant-accessible-name/meta.js

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

package/lib/no-redundant-aria-prop/index.d.ts

@@ -0,0 +1,10 @@
+import type { Options } from '../wai-aria/types.js';
+/**
+ * Split from the former `wai-aria-implicit-props` rule (#3989): the
+ * "redundant" half. See `checkingRedundantAriaProp`'s JSDoc for the full
+ * spec citation. Should-level (ARIA in HTML §6 recommends the native
+ * attribute), so this rule keeps the former rule's `warning` default —
+ * contrast `no-contradictory-aria-prop`'s `error`.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;