@markuplint/rules 4.11.2 → 5.0.0-alpha.0

package/lib/permitted-contents/utils.js

@@ -1,18 +1,15 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Collection_locked, _Collection_matched, _Collection_nodes, _Collection_origin;
 import { createSelector } from '@markuplint/selector';
 import { bgGreen, green, bgRed, bgBlue, blue, bgMagenta, cyan } from './debug.js';
 import { transparentMode } from './represent-transparent-nodes.js';
+/**
+ * Determines whether a given value is a terminal model (a selector string or an array
+ * of selector strings) rather than a nested array of content model patterns.
+ * Distinguishes between `Model` (leaf-level selectors) and `PermittedContentPattern[]`
+ * (structural pattern arrays that require further recursive evaluation).
+ *
+ * @param model - The value to check, either a terminal model or a nested pattern array.
+ * @returns True if the value is a terminal model (string or string array), false if it is a pattern array.
+ */
 export function isModel(model) {
     if (typeof model === 'string') {
         return true;
@@ -29,6 +26,16 @@ export function isModel(model) {
     }
     return modelMode;
 }
+/**
+ * Tests whether a child node matches a CSS selector string using the markuplint
+ * selector engine. Returns whether the node matched and, if not, the deepest
+ * unmatched descendant node for diagnostic purposes.
+ *
+ * @param selector - The CSS selector string to test against.
+ * @param node - The child node to test.
+ * @param specs - The spec data passed to the selector engine for attribute resolution.
+ * @returns An object with `matched: true` if the node matches, or `matched: false` with an optional `not` node.
+ */
 export function matches(selector, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 node, specs) {
@@ -48,6 +55,14 @@ node, specs) {
         not,
     };
 }
+/**
+ * Traverses a chain of nested `:has()` selector results to find the deepest
+ * descendant nodes that caused a selector mismatch. Used to provide precise
+ * error reporting by identifying the actual offending node in nested selectors.
+ *
+ * @param selectorResult - A matched selector result that may contain nested `:has()` results.
+ * @returns The deepest descendant child nodes from the nested selector chain.
+ */
 function descendants(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 selectorResult) {
@@ -58,6 +73,7 @@ selectorResult) {
                 nodes = dep.nodes;
                 continue;
             }
+            // eslint-disable-next-line no-useless-assignment
             selectorResult = dep;
             continue;
         }
@@ -65,24 +81,74 @@ selectorResult) {
     }
     return nodes;
 }
+/**
+ * Type guard that checks whether a content model pattern is a "require" pattern,
+ * indicating one or more required occurrences of a specific element or model.
+ *
+ * @param content - The content model pattern to check.
+ * @returns True if the pattern has a `require` property.
+ */
 export function isRequire(content) {
     return 'require' in content;
 }
+/**
+ * Type guard that checks whether a content model pattern is an "optional" pattern,
+ * indicating zero or one occurrences of a specific element or model.
+ *
+ * @param content - The content model pattern to check.
+ * @returns True if the pattern has an `optional` property.
+ */
 export function isOptional(content) {
     return 'optional' in content;
 }
+/**
+ * Type guard that checks whether a content model pattern is a "oneOrMore" pattern,
+ * indicating one or more occurrences of a specific element or model.
+ *
+ * @param content - The content model pattern to check.
+ * @returns True if the pattern has a `oneOrMore` property.
+ */
 export function isOneOrMore(content) {
     return 'oneOrMore' in content;
 }
+/**
+ * Type guard that checks whether a content model pattern is a "zeroOrMore" pattern,
+ * indicating zero or more occurrences of a specific element or model.
+ *
+ * @param content - The content model pattern to check.
+ * @returns True if the pattern has a `zeroOrMore` property.
+ */
 export function isZeroOrMore(content) {
     return 'zeroOrMore' in content;
 }
+/**
+ * Type guard that checks whether a content model pattern is a "choice" pattern,
+ * representing an alternation between multiple possible content model branches.
+ *
+ * @param content - The content model pattern to check.
+ * @returns True if the pattern has a `choice` property.
+ */
 export function isChoice(content) {
     return 'choice' in content;
 }
+/**
+ * Type guard that checks whether a content model pattern is a "transparent" pattern,
+ * indicating the element inherits its parent's content model.
+ *
+ * @param content - The content model pattern to check.
+ * @returns True if the pattern has a `transparent` property.
+ */
 export function isTransparent(content) {
     return 'transparent' in content;
 }
+/**
+ * Normalizes a quantified content model pattern (require, optional, oneOrMore, or zeroOrMore)
+ * into a uniform representation with the inner model, minimum count, maximum count,
+ * a regex-like repeat sign for debug display, and the appropriate missing-node error type.
+ *
+ * @param pattern - A quantified content model pattern to normalize.
+ * @returns An object with `model`, `min`, `max`, `repeat` sign, and optional `missingType`.
+ */
 export function normalizeModel(pattern) {
     let model;
     let min;
@@ -137,18 +203,36 @@ export function normalizeModel(pattern) {
         missingType,
     };
 }
+/**
+ * Merges two Hints objects, combining their properties and selecting the
+ * `missing` hint with the higher `barelyMatchedElements` count (i.e., the
+ * one closest to a successful match) for the most useful error diagnostics.
+ *
+ * @param a - The first hints object.
+ * @param b - The second hints object.
+ * @returns A merged hints object with undefined properties removed.
+ */
 export function mergeHints(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 a, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 b) {
-    const missing = [a.missing, b.missing].sort((a, b) => (b?.barelyMatchedElements ?? 0) - (a?.barelyMatchedElements ?? 0))[0];
+    const missing = [a.missing, b.missing].toSorted((a, b) => (b?.barelyMatchedElements ?? 0) - (a?.barelyMatchedElements ?? 0))[0];
     return cleanObject({
         ...a,
         ...b,
         missing: missing && cleanObject(missing),
     });
 }
+/**
+ * Creates a shallow copy of an object with all `undefined` values removed.
+ * Used to produce clean hint objects for result reporting without
+ * extraneous undefined properties.
+ *
+ * @template T - The object type.
+ * @param object - The source object to clean.
+ * @returns A new object containing only the defined properties of the input.
+ */
 export function cleanObject(object) {
     const newObject = {};
     for (const [key, value] of Object.entries(object)) {
@@ -158,57 +242,115 @@ export function cleanObject(object) {
     }
     return newObject;
 }
+/**
+ * Tracks matched and unmatched child nodes during content model validation.
+ * Provides operations for adding matched nodes, backtracking to a locked state,
+ * capping matches at a maximum count, and generating colored debug output.
+ *
+ * The collection maintains an ordered set of original nodes and partitions them
+ * into matched and unmatched sets as the validation algorithm progresses.
+ */
 export class Collection {
+    #locked = new Set();
+    #matched = new Set();
+    #nodes;
+    #origin;
+    /**
+     * Creates a new Collection from the given child nodes.
+     *
+     * @param origin - The initial list of child nodes to track.
+     */
     constructor(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     origin) {
-        _Collection_locked.set(this, new Set());
-        _Collection_matched.set(this, new Set());
-        _Collection_nodes.set(this, void 0);
-        _Collection_origin.set(this, void 0);
-        __classPrivateFieldSet(this, _Collection_origin, [...origin], "f");
-        __classPrivateFieldSet(this, _Collection_nodes, new Set(__classPrivateFieldGet(this, _Collection_origin, "f")), "f");
+        this.#origin = [...origin];
+        this.#nodes = new Set(this.#origin);
     }
+    /**
+     * Returns a copy of the currently matched nodes in insertion order.
+     */
     get matched() {
-        return [...__classPrivateFieldGet(this, _Collection_matched, "f")];
+        return [...this.#matched];
     }
+    /**
+     * Returns the number of currently matched nodes.
+     */
     get matchedCount() {
-        return __classPrivateFieldGet(this, _Collection_matched, "f").size;
+        return this.#matched.size;
     }
+    /**
+     * Returns a copy of all original nodes in their original order.
+     */
     get nodes() {
-        return [...__classPrivateFieldGet(this, _Collection_origin, "f")];
+        return [...this.#origin];
     }
+    /**
+     * Returns the nodes that have not yet been matched, preserving original order.
+     */
     get unmatched() {
-        return [...__classPrivateFieldGet(this, _Collection_nodes, "f")].filter(n => !__classPrivateFieldGet(this, _Collection_matched, "f").has(n));
+        return [...this.#nodes].filter(n => !this.#matched.has(n));
     }
+    /**
+     * Adds nodes to the matched set. All nodes must belong to the original
+     * collection; external nodes will cause a ReferenceError.
+     *
+     * @param nodes - The child nodes to mark as matched.
+     * @returns True if the matched set grew (new nodes were added), false otherwise.
+     */
     addMatched(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     nodes) {
-        const i = __classPrivateFieldGet(this, _Collection_matched, "f").size;
+        const i = this.#matched.size;
         for (const node of nodes) {
-            if (!__classPrivateFieldGet(this, _Collection_nodes, "f").has(node)) {
+            if (!this.#nodes.has(node)) {
                 throw new ReferenceError(`External Node: ${node.nodeName}`);
             }
-            __classPrivateFieldGet(this, _Collection_matched, "f").add(node);
+            this.#matched.add(node);
         }
-        return i < __classPrivateFieldGet(this, _Collection_matched, "f").size;
+        return i < this.#matched.size;
     }
+    /**
+     * Reverts the matched set to the last locked state, discarding
+     * any matches added since the last `lock()` call. Used for backtracking
+     * when a pattern match attempt fails after a zero-match.
+     */
     back() {
-        __classPrivateFieldSet(this, _Collection_matched, new Set(__classPrivateFieldGet(this, _Collection_locked, "f")), "f");
+        this.#matched = new Set(this.#locked);
     }
+    /**
+     * Saves the current matched set as a checkpoint that `back()` can
+     * revert to. Called after a successful backtrack recovery to preserve
+     * the known-good state.
+     */
     lock() {
-        __classPrivateFieldSet(this, _Collection_locked, new Set(__classPrivateFieldGet(this, _Collection_matched, "f")), "f");
+        this.#locked = new Set(this.#matched);
     }
+    /**
+     * Trims the matched set to at most `max` entries by removing
+     * the most recently added nodes beyond the limit. Used when the
+     * maximum occurrence count for a pattern is exceeded.
+     *
+     * @param max - The maximum number of matched nodes to retain.
+     */
     max(max) {
-        const sliced = [...__classPrivateFieldGet(this, _Collection_matched, "f")].slice(max);
+        const sliced = [...this.#matched].slice(max);
         for (const n of sliced)
-            __classPrivateFieldGet(this, _Collection_matched, "f").delete(n);
+            this.#matched.delete(n);
     }
+    /**
+     * Returns a colored string representation of all nodes for debug logging.
+     * Matched nodes are shown in green, locked nodes in bold green, unmatched
+     * extra nodes in red (when highlighted), and transparent-mode nodes in
+     * blue/cyan/magenta variants.
+     *
+     * @param highlightExtraNodes - When true, unmatched nodes are highlighted in red/magenta.
+     * @returns A formatted string like `[ <div>, <span>, <p> ]` with ANSI colors.
+     */
     toString(highlightExtraNodes = false) {
         const out = [];
-        for (const n of __classPrivateFieldGet(this, _Collection_origin, "f")) {
+        for (const n of this.#origin) {
             const raw = n.is(n.TEXT_NODE) ? `:text(${n.raw.replaceAll('\n', '\\n')})` : n.raw;
-            if (__classPrivateFieldGet(this, _Collection_locked, "f").has(n)) {
+            if (this.#locked.has(n)) {
                 if (transparentMode.has(n)) {
                     out.push(bgBlue.bold(raw));
                 }
@@ -217,7 +359,7 @@ export class Collection {
                 }
                 continue;
             }
-            if (__classPrivateFieldGet(this, _Collection_matched, "f").has(n)) {
+            if (this.#matched.has(n)) {
                 if (transparentMode.has(n)) {
                     out.push(blue.bold(raw));
                 }
@@ -245,9 +387,23 @@ export class Collection {
         return `[ ${out.join(', ')} ]`;
     }
 }
-_Collection_locked = new WeakMap(), _Collection_matched = new WeakMap(), _Collection_nodes = new WeakMap(), _Collection_origin = new WeakMap();
+/**
+ * Error class representing an unsupported content model feature.
+ * Thrown when the validation engine encounters a pattern type or
+ * configuration that is not yet implemented.
+ */
 export class UnsupportedError extends Error {
 }
+/**
+ * Formats a content model (terminal model or pattern array) and its repeat sign
+ * into a regex-like string for debug logging output. Terminal selectors are
+ * rendered as `<selector>`, arrays of selectors as `(<s1>|<s2>)`, and
+ * nested patterns are recursively formatted.
+ *
+ * @param model - The model or pattern array to format.
+ * @param repeat - The quantifier sign to append (e.g., `+`, `*`, `?`, or `{m,n}`).
+ * @returns A human-readable regex-like string representation of the model.
+ */
 export function modelLog(model, repeat) {
     if (!isModel(model)) {
         return orderLog(model, repeat);
@@ -257,11 +413,28 @@ export function modelLog(model, repeat) {
     }
     return `(<${model.join('>|<')}>)${repeat}`;
 }
+/**
+ * Formats an ordered array of content model patterns into a regex-like
+ * string for debug logging, with an optional repeat quantifier wrapping
+ * the entire sequence.
+ *
+ * @param order - The ordered array of patterns to format.
+ * @param repeat - The quantifier sign to wrap around the sequence.
+ * @returns A formatted string representation of the ordered patterns.
+ */
 function orderLog(order, repeat) {
     return order.length === 1 && order[0]
         ? markRepeat(patternLog(order[0]), repeat)
         : markRepeat(order.map(pattern => patternLog(pattern)).join(''), repeat);
 }
+/**
+ * Formats a single content model pattern into a regex-like string for debug logging.
+ * Handles transparent, choice, and quantified patterns by dispatching to the
+ * appropriate formatting logic.
+ *
+ * @param pattern - The content model pattern to format.
+ * @returns A human-readable string representation of the pattern.
+ */
 function patternLog(pattern) {
     if (isTransparent(pattern)) {
         // 適当
@@ -273,6 +446,14 @@ function patternLog(pattern) {
     const { model, repeat } = normalizeModel(pattern);
     return modelLog(model, repeat);
 }
+/**
+ * Wraps a pattern string with parentheses and a repeat quantifier if a
+ * repeat sign is present. If no repeat sign is given, returns the pattern unchanged.
+ *
+ * @param pattern - The pattern string to wrap.
+ * @param repeat - The quantifier sign to append, or an empty string for no repetition.
+ * @returns The pattern string, optionally wrapped as `(pattern)quantifier`.
+ */
 function markRepeat(pattern, repeat) {
     return repeat ? `(${pattern})${repeat}` : pattern;
 }

package/lib/placeholder-label-option/index.d.ts

@@ -1,2 +1,9 @@
+/**
+ * Rule that validates required `<select>` elements have a placeholder label option.
+ *
+ * Per the HTML spec, a `<select>` with `required`, without `multiple`, and with a
+ * display size of 1 must have a placeholder label option (first `<option>` with
+ * an empty value directly under `<select>`).
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
 export default _default;

package/lib/placeholder-label-option/index.js

@@ -1,5 +1,12 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that validates required `<select>` elements have a placeholder label option.
+ *
+ * Per the HTML spec, a `<select>` with `required`, without `multiple`, and with a
+ * display size of 1 must have a placeholder label option (first `<option>` with
+ * an empty value directly under `<select>`).
+ */
 export default createRule({
     meta: meta,
     verify({ document, report, t }) {
@@ -18,13 +25,13 @@ export default createRule({
     },
 });
 /**
- * > If a select element has a required attribute specified,
- * > does not have a multiple attribute specified,
- * > and has a display size of 1,
- * > then the select element must have a placeholder label option.
+ * Determines whether a `<select>` element requires a placeholder label option.
  *
- * @param select
- * @returns
+ * Per the HTML spec, a select element needs a placeholder label option when it
+ * has `required`, does not have `multiple`, and has a display size of 1.
+ *
+ * @param select - The `<select>` element to evaluate.
+ * @returns `true` if the select element requires a placeholder label option.
  */
 function needPlaceholderLabelOption(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -44,16 +51,13 @@ select) {
     return true;
 }
 /**
- * > If a select element has a required attribute specified,
- * > does not have a multiple attribute specified,
- * > and has a display size of 1;
- * > and if the value of the first option element
- * > in the select element's list of options (if any) is the empty string,
- * > and that option element's parent node is the select element (and not an optgroup element),
- * > then that option is the select element's **placeholder label option**.
+ * Checks whether a `<select>` element already has a valid placeholder label option.
+ *
+ * A placeholder label option is the first `<option>` whose value is the empty string
+ * and whose parent is the `<select>` element itself (not an `<optgroup>`).
  *
- * @param select
- * @returns
+ * @param select - The `<select>` element to check.
+ * @returns `true` if the element has a valid placeholder label option.
  */
 function hasPlaceholderLabelOption(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types

package/lib/placeholder-label-option/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for the `placeholder-label-option` rule, categorized as validation. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/placeholder-label-option/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for the `placeholder-label-option` rule, categorized as validation. */
 export default {
     category: 'validation',
 };

package/lib/redundant-accessible-name/index.d.ts

@@ -0,0 +1,10 @@
+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;
+}>>;
+export default _default;

package/lib/redundant-accessible-name/index.js

@@ -0,0 +1,123 @@
+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',
+    defaultOptions: {
+        checkTitleFallback: false,
+        checkPlaceholderFallback: false,
+    },
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            const ariaVersion = ARIA_RECOMMENDED_VERSION;
+            // Skip mutable elements (template expressions etc.)
+            if (accnameMayBeMutable(el, document)) {
+                return;
+            }
+            // Skip hidden elements
+            if (!isExposed(el, document.specs, ariaVersion)) {
+                return;
+            }
+            // Skip nameFrom: "prohibited" roles (generic, none, presentation)
+            const computed = getComputedRole(document.specs, el, ariaVersion);
+            if (computed.role?.accessibleNameProhibited) {
+                return;
+            }
+            const sources = collectNamingSources(el, document, el.rule.options, computed);
+            if (sources.length >= 2) {
+                const winner = sources[0];
+                const overridden = sources.slice(1);
+                for (const loser of overridden) {
+                    report({
+                        scope: el,
+                        message: t('The accessible name from "{0*}" overrides "{1*}"', winner.label, loser.label),
+                    });
+                }
+            }
+        });
+    },
+});
+function collectNamingSources(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+document, options, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+computed) {
+    const sources = [];
+    // 1. aria-labelledby
+    const ariaLabelledby = el.getAttribute('aria-labelledby');
+    if (ariaLabelledby && ariaLabelledby.trim()) {
+        const ids = ariaLabelledby.trim().split(/\s+/);
+        const hasResolvableId = ids.some(id => document.querySelector(`[id="${id}"]`));
+        if (hasResolvableId) {
+            sources.push({ label: 'aria-labelledby' });
+        }
+    }
+    // 2. aria-label
+    const ariaLabel = el.getAttribute('aria-label');
+    if (ariaLabel && ariaLabel.trim()) {
+        sources.push({ label: 'aria-label' });
+    }
+    // 3. label (explicit or implicit) — only for labelable elements
+    const ownedLabel = getOwnedLabel(el, document);
+    if (ownedLabel) {
+        sources.push({ label: 'label' });
+    }
+    // 4. alt — img, area, input[type=image]
+    if (el.matches('img, area, input[type=image]')) {
+        const alt = el.getAttribute('alt');
+        if (alt != null && alt.trim()) {
+            sources.push({ label: 'alt' });
+        }
+    }
+    // 5. content — role allows nameFromContent
+    if (computed.role?.accessibleNameFromContent) {
+        const text = el.textContent.trim();
+        if (text) {
+            sources.push({ label: 'content' });
+        }
+    }
+    // 6. value — input[type=button/submit/reset]
+    if (el.matches('input[type=button], input[type=submit], input[type=reset]')) {
+        const value = el.getAttribute('value');
+        if (value != null && value.trim()) {
+            sources.push({ label: 'value' });
+        }
+    }
+    // 7. legend — fieldset (direct child only)
+    if (el.matches('fieldset')) {
+        const legend = el.querySelector(':scope > legend');
+        if (legend && legend.textContent.trim()) {
+            sources.push({ label: 'legend' });
+        }
+    }
+    // 8. caption — table (direct child only)
+    if (el.matches('table')) {
+        const caption = el.querySelector(':scope > caption');
+        if (caption && caption.textContent.trim()) {
+            sources.push({ label: 'caption' });
+        }
+    }
+    // 9. title (optional)
+    if (options.checkTitleFallback) {
+        const title = el.getAttribute('title');
+        if (title != null && title.trim()) {
+            sources.push({ label: 'title' });
+        }
+    }
+    // 10. placeholder (optional)
+    if (options.checkPlaceholderFallback) {
+        const placeholder = el.getAttribute('placeholder');
+        if (placeholder != null && placeholder.trim()) {
+            sources.push({ label: 'placeholder' });
+        }
+    }
+    return sources;
+}

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

@@ -0,0 +1,5 @@
+/** Rule metadata for the `redundant-accessible-name` rule, categorized as accessibility. */
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

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

@@ -0,0 +1,4 @@
+/** Rule metadata for the `redundant-accessible-name` rule, categorized as accessibility. */
+export default {
+    category: 'a11y',
+};

package/lib/require-accessible-name/index.d.ts

@@ -1,6 +1,12 @@
 import type { ARIAVersion } from '@markuplint/ml-spec';
-type Option = {
-    ariaVersion: ARIAVersion;
-};
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
+/**
+ * Rule that requires elements with roles that need accessible names to have one.
+ *
+ * For each element exposed to the accessibility tree whose computed ARIA role
+ * has `accessibleNameRequired` set to `true`, this rule verifies that the element
+ * provides a non-empty accessible name.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
+    ariaVersion: ARIAVersion | undefined;
+}>>;
 export default _default;