@markuplint/rules 2.4.2 → 3.0.0-alpha.0

package/lib/wai-aria/checkings/presentational-children.d.ts

@@ -0,0 +1,29 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+/**
+ * Presentational Children
+ *
+ * @see https://www.w3.org/TR/wai-aria/#childrenArePresentational
+ * @see https://w3c.github.io/aria/#childrenArePresentational
+ *
+ * > The DOM descendants are presentational.
+ * > user agents SHOULD NOT expose descendants of
+ * > this element through the platform accessibility API.
+ * > If user agents do not hide the descendant nodes,
+ * > some information may be read twice.
+ *
+ * @see https://w3c.github.io/aria/#tree_exclusion
+ *
+ * > Any descendants of elements that have the characteristic "Children Presentational: True"
+ * > unless the descendant is not allowed to be presentational
+ * > because it meets one of the conditions for exception described
+ * > in Presentational Roles Conflict Resolution.
+ * > However, the text content of any excluded descendants is included.
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ *
+ *  > Text equivalents for hidden referenced objects
+ * > may still be used in the name and description computation
+ * > even when not included in the accessibility tree.
+ */
+export declare const checkingPresentationalChildren: ElementChecker<boolean, Options>;

package/lib/wai-aria/checkings/presentational-children.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingPresentationalChildren = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Presentational Children
+ *
+ * @see https://www.w3.org/TR/wai-aria/#childrenArePresentational
+ * @see https://w3c.github.io/aria/#childrenArePresentational
+ *
+ * > The DOM descendants are presentational.
+ * > user agents SHOULD NOT expose descendants of
+ * > this element through the platform accessibility API.
+ * > If user agents do not hide the descendant nodes,
+ * > some information may be read twice.
+ *
+ * @see https://w3c.github.io/aria/#tree_exclusion
+ *
+ * > Any descendants of elements that have the characteristic "Children Presentational: True"
+ * > unless the descendant is not allowed to be presentational
+ * > because it meets one of the conditions for exception described
+ * > in Presentational Roles Conflict Resolution.
+ * > However, the text content of any excluded descendants is included.
+ *
+ * @see https://w3c.github.io/aria/#tree_inclusion
+ *
+ *  > Text equivalents for hidden referenced objects
+ * > may still be used in the name and description computation
+ * > even when not included in the accessibility tree.
+ */
+const checkingPresentationalChildren = ({ el }) => t => {
+    const ancestor = getAncestorHasPresentationalChildren(el);
+    if (!ancestor) {
+        return;
+    }
+    if (!ancestor.role) {
+        return;
+    }
+    const hasAriaAttr = Array.from(el.attributes).some(attr => /^aria-|^role$/i.test(attr.name));
+    if (!hasAriaAttr) {
+        return;
+    }
+    return {
+        scope: el,
+        message: t('it may be ineffective because {0}', t("it has {0} as an ancestor that doesn't expose its descendants to the accessibility tree", t('the "{0*}" {1}', ancestor.role.name, 'role'))),
+    };
+};
+exports.checkingPresentationalChildren = checkingPresentationalChildren;
+function getAncestorHasPresentationalChildren(el) {
+    var _a;
+    let current = el.parentElement;
+    while (current) {
+        const computed = (0, ml_spec_1.getComputedRole)(el.ownerMLDocument.specs, current, el.rule.option.version);
+        if ((_a = computed.role) === null || _a === void 0 ? void 0 : _a.childrenPresentational) {
+            return computed;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}

package/lib/wai-aria/checkings/required-owned-elements.d.ts

@@ -0,0 +1,11 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+import type { ARIARole } from '@markuplint/ml-spec';
+/**
+ * Required Owned Elements
+ *
+ * @see https://w3c.github.io/aria/#mustContain
+ */
+export declare const checkingRequiredOwnedElements: ElementChecker<boolean, Options, {
+    role?: ARIARole | null;
+}>;

package/lib/wai-aria/checkings/required-owned-elements.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingRequiredOwnedElements = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+/**
+ * Required Owned Elements
+ *
+ * @see https://w3c.github.io/aria/#mustContain
+ */
+const checkingRequiredOwnedElements = ({ el, role }) => t => {
+    if (!role) {
+        return;
+    }
+    if (!role.requiredOwnedElements.length) {
+        return;
+    }
+    /**
+     * > There may be times that required owned elements are missing,
+     * > for example, while editing or while loading a data set.
+     * > When a widget is missing required owned elements due to script execution or loading,
+     * > authors MUST mark a containing element with aria-busy equal to true.
+     * > For example, until a page is fully initialized and complete,
+     * > an author could mark the document element as busy.
+     *
+     * Stop to evaluate when it has `aria-busy=true` for it considers the contents are missing.
+     */
+    if (el.matches('[aria-busy="true" i]')) {
+        return;
+    }
+    // TODO: Needs to resolve `aria-own`
+    if (!el.children.length) {
+        return {
+            scope: el,
+            message: t('{0}. Or, {1}', t('Require {0} to content', t('the {0*} {1}', t(role.requiredOwnedElements), 'role')), t('require {0}', 'aria-busy="true"')),
+        };
+    }
+    const children = Array.from(el.childNodes).map(child => {
+        if (child.is(child.ELEMENT_NODE)) {
+            const computedChild = (0, ml_spec_1.getComputedRole)(child.ownerMLDocument.specs, child, child.rule.option.version);
+            if (role.requiredOwnedElements.some(ownedRole => (0, ml_spec_1.isRequiredOwnedElement)(computedChild, ownedRole, child.ownerMLDocument.specs, child.rule.option.version))) {
+                return 'REQUIRED';
+            }
+            return 'OTHER';
+        }
+        else if (child.MARKUPLINT_PREPROCESSOR_BLOCK) {
+            return 'PB';
+        }
+        return 'NO_ELEMENT';
+    });
+    if (children.includes('PB')) {
+        return {
+            scope: el,
+            message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), t(role.requiredContextRole.map(ownedRole => t('the "{0*}" {1}', ownedRole, 'role')))),
+        };
+    }
+    if (!children.includes('REQUIRED')) {
+        return {
+            scope: el,
+            message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), t('the {0*} {1}', t(role.requiredOwnedElements), 'roles')),
+        };
+    }
+};
+exports.checkingRequiredOwnedElements = checkingRequiredOwnedElements;

package/lib/wai-aria/checkings/required-prop.d.ts

@@ -0,0 +1,9 @@
+import type { Options } from '../types';
+import type { ElementChecker } from '@markuplint/ml-core';
+import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
+export declare const checkingRequiredProp: ElementChecker<boolean, Options, {
+    role?: (ARIARole & {
+        isImplicit?: boolean;
+    }) | null;
+    propSpecs: ARIAProperty[];
+}>;

package/lib/wai-aria/checkings/required-prop.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingRequiredProp = void 0;
+const checkingRequiredProp = ({ el, role, propSpecs }) => t => {
+    var _a;
+    if (!role) {
+        return;
+    }
+    if (role.isImplicit) {
+        return;
+    }
+    const requiredProps = role.ownedProperties.filter(s => s.required).map(s => s.name);
+    for (const requiredProp of requiredProps) {
+        const has = el.attributes.some(attr => {
+            const attrName = attr.name.toLowerCase();
+            return attrName === requiredProp;
+        });
+        if (!has) {
+            const propSpec = propSpecs.find(p => p.name === requiredProp);
+            return {
+                scope: el,
+                message: t('{0:c} on {1}', t('Require {0}', t('the "{0*}" {1}', requiredProp, `ARIA ${(_a = propSpec === null || propSpec === void 0 ? void 0 : propSpec.type) !== null && _a !== void 0 ? _a : 'property'}`)), t('the "{0*}" {1}', role.name, 'role')),
+            };
+        }
+    }
+};
+exports.checkingRequiredProp = checkingRequiredProp;

package/lib/wai-aria/checkings/value.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from '../types';
+import type { AttrChecker } from '@markuplint/ml-core';
+import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
+export declare const checkingValue: AttrChecker<boolean, Options, {
+    role?: ARIARole | null;
+    propSpecs: ARIAProperty[];
+}>;

package/lib/wai-aria/checkings/value.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingValue = void 0;
+const helpers_1 = require("../../helpers");
+const checkingValue = ({ attr, role, propSpecs }) => t => {
+    var _a;
+    if (attr.isDynamicValue) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    const result = (0, helpers_1.checkAria)(attr.ownerMLDocument.specs, attr.name, attr.value, attr.rule.option.version, role === null || role === void 0 ? void 0 : role.name);
+    if (result.isValid) {
+        return;
+    }
+    return {
+        scope: attr,
+        message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0}"', attr.value), 'disallowed'), t('the "{0*}" {1}', attr.name, `ARIA ${(_a = propSpec === null || propSpec === void 0 ? void 0 : propSpec.type) !== null && _a !== void 0 ? _a : 'property'}`)) +
+            ('enum' in result && result.enum.length ? t('. ') + t('Allowed values are: {0}', t(result.enum)) : ''),
+    };
+};
+exports.checkingValue = checkingValue;

package/lib/wai-aria/index.d.ts

@@ -1,10 +1,3 @@
-declare type Options = {
-    checkingValue?: boolean;
-    checkingDeprecatedProps?: boolean;
-    permittedAriaRoles?: boolean;
-    disallowSetImplicitRole?: boolean;
-    disallowSetImplicitProps?: boolean;
-    disallowDefaultValue?: boolean;
-};
+import type { Options } from './types';
 declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, Options>;
 export default _default;

package/lib/wai-aria/index.js

@@ -2,237 +2,96 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
 const helpers_1 = require("../helpers");
+const abstract_role_1 = require("./checkings/abstract-role");
+const default_value_1 = require("./checkings/default-value");
+const deprecated_props_1 = require("./checkings/deprecated-props");
+const disallowed_prop_1 = require("./checkings/disallowed-prop");
+const implicit_props_1 = require("./checkings/implicit-props");
+const implicit_role_1 = require("./checkings/implicit-role");
+const interaction_in_hidden_1 = require("./checkings/interaction-in-hidden");
+const no_global_prop_1 = require("./checkings/no-global-prop");
+const non_existant_role_1 = require("./checkings/non-existant-role");
+const permitted_roles_1 = require("./checkings/permitted-roles");
+const presentational_children_1 = require("./checkings/presentational-children");
+const required_owned_elements_1 = require("./checkings/required-owned-elements");
+const required_prop_1 = require("./checkings/required-prop");
+const value_1 = require("./checkings/value");
 exports.default = (0, ml_core_1.createRule)({
     defaultOptions: {
         checkingValue: true,
         checkingDeprecatedProps: true,
         permittedAriaRoles: true,
+        checkingRequiredOwnedElements: true,
+        checkingPresentationalChildren: false,
+        checkingInteractionInHidden: false,
         disallowSetImplicitRole: true,
         disallowSetImplicitProps: true,
         disallowDefaultValue: false,
+        version: '1.2',
     },
     async verify({ document, report, t }) {
-        await document.walkOn('Element', node => {
-            const attrSpecs = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
-            const html = (0, helpers_1.htmlSpec)(document.specs, node.nodeName);
-            const { roles, ariaAttrs } = (0, helpers_1.ariaSpec)(document.specs);
-            if (!html || !attrSpecs) {
+        await document.walkOn('Element', el => {
+            const roleAttr = el.getAttributeNode('role');
+            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            const ariaAttrs = new helpers_1.Collection(roleAttr, ...propAttrs);
+            const elSpec = (0, ml_core_1.getSpec)(el, document.specs);
+            if (!elSpec) {
                 return;
             }
-            const roleAttrTokens = node.getAttributeToken('role');
-            const roleAttr = roleAttrTokens[0];
-            // Roles in the spec
-            if (roleAttr) {
-                const value = roleAttr.getValue().potential.trim().toLowerCase();
-                const existedRole = roles.find(role => role.name === value);
-                if (!existedRole) {
-                    // Not exist
+            if (!elSpec.globalAttrs['#ARIAAttrs']) {
+                for (const ariaAttr of ariaAttrs) {
                     report({
-                        scope: node,
-                        message: t('{0} according to {1}', t('{0} does not exist', t('the "{0*}" {1}', value, 'role')), 'the WAI-ARIA specification') + `This "${value}" role does not exist in WAI-ARIA.`,
-                        line: roleAttr.startLine,
-                        col: roleAttr.startCol,
-                        raw: roleAttr.raw,
+                        scope: ariaAttr,
+                        message: 'ARIA attribute is disallowed',
                     });
                 }
-                else if (existedRole.isAbstract) {
-                    // the abstract role
-                    report({
-                        scope: node,
-                        message: t('{0} is {1}', t('the "{0*}" {1}', value, 'role'), 'the abstract role'),
-                        line: roleAttr.startLine,
-                        col: roleAttr.startCol,
-                        raw: roleAttr.raw,
-                    });
+                return;
+            }
+            const computed = (0, ml_core_1.getComputedRole)(document.specs, el, el.rule.option.version);
+            const { props: propSpecs } = (0, ml_core_1.ariaSpecs)(document.specs, el.rule.option.version);
+            if (roleAttr) {
+                if (report((0, non_existant_role_1.checkingNonExistantRole)({ attr: roleAttr }))) {
+                    return;
                 }
-                // Set the implicit role explicitly
-                if (node.rule.option.disallowSetImplicitRole) {
-                    const implictRole = (0, helpers_1.getImplicitRole)(document.specs, node);
-                    if (implictRole && implictRole === value) {
-                        // the implicit role
-                        report({
-                            scope: node,
-                            message: t('{0} is {1}', t('the "{0*}" {1}', value, 'role'), t('{0} of {1}', 'the implicit role', t('the "{0*}" {1}', node.nodeName, 'element'))),
-                            line: roleAttr.startLine,
-                            col: roleAttr.startCol,
-                            raw: roleAttr.raw,
-                        });
-                    }
+                if (report((0, abstract_role_1.checkingAbstractRole)({ attr: roleAttr }))) {
+                    return;
                 }
-                // Permitted ARIA Roles
-                if (node.rule.option.permittedAriaRoles) {
-                    const permittedRoles = (0, helpers_1.getPermittedRoles)(document.specs, node);
-                    if (permittedRoles === false) {
-                        report({
-                            scope: node,
-                            message: t('{0} according to {1}', t('Cannot overwrite {0}', t('{0} of {1}', t('the {0}', 'role'), t('the "{0*}" {1}', node.nodeName, 'element'))), 'ARIA in HTML specification'),
-                            line: roleAttr.startLine,
-                            col: roleAttr.startCol,
-                            raw: roleAttr.raw,
-                        });
-                    }
-                    else if (Array.isArray(permittedRoles) && !permittedRoles.includes(value)) {
-                        report({
-                            scope: node,
-                            message: t('{0} according to {1}', t('Cannot overwrite {0} to {1}', t('the "{0*}" {1}', value, 'role'), t('the "{0*}" {1}', node.nodeName, 'element')), 'ARIA in HTML specification'),
-                            line: roleAttr.startLine,
-                            col: roleAttr.startCol,
-                            raw: roleAttr.raw,
-                        });
-                    }
+                report((0, required_prop_1.checkingRequiredProp)({ el, role: computed.role, propSpecs }));
+                if (el.rule.option.disallowSetImplicitRole) {
+                    report((0, implicit_role_1.checkingImplicitRole)({ attr: roleAttr }));
                 }
-            }
-            const computedRole = (0, helpers_1.getComputedRole)(document.specs, node);
-            if (computedRole) {
-                const role = (0, helpers_1.getRoleSpec)(document.specs, computedRole.name);
-                if (role) {
-                    // Checking aria-* on the role
-                    for (const attr of node.attributes) {
-                        const attrName = attr.getName().potential.trim().toLowerCase();
-                        if (/^aria-/i.test(attrName)) {
-                            const statesAndProp = role.statesAndProps.find(s => s.name === attrName);
-                            if (statesAndProp) {
-                                if (node.rule.option.checkingDeprecatedProps && statesAndProp.deprecated) {
-                                    report({
-                                        scope: node,
-                                        message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'ARIA state/property'), 'deprecated'), t('the "{0*}" {1}', role.name, 'role')),
-                                        line: attr.startLine,
-                                        col: attr.startCol,
-                                        raw: attr.raw,
-                                    });
-                                }
-                            }
-                            else {
-                                report({
-                                    scope: node,
-                                    message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'ARIA state/property'), 'disallowed'), t('the "{0*}" {1}', role.name, 'role')),
-                                    line: attr.startLine,
-                                    col: attr.startCol,
-                                    raw: attr.raw,
-                                });
-                            }
-                        }
-                    }
-                    // Checing required props
-                    if (!computedRole.isImplicit) {
-                        const requiredProps = role.statesAndProps.filter(s => s.required).map(s => s.name);
-                        for (const requiredProp of requiredProps) {
-                            const has = node.attributes.some(attr => {
-                                const attrName = attr.getName().potential.trim().toLowerCase();
-                                return attrName === requiredProp;
-                            });
-                            if (!has) {
-                                report({
-                                    scope: node,
-                                    message: t('{0:c} on {1}', t('Require {0}', t('the "{0*}" {1}', requiredProp, 'ARIA state/property')), t('the "{0*}" {1}', role.name, 'role')),
-                                });
-                            }
-                        }
-                    }
+                if (el.rule.option.permittedAriaRoles) {
+                    report((0, permitted_roles_1.checkingPermittedRoles)({ attr: roleAttr }));
                 }
             }
-            else {
-                // No role element
-                const { ariaAttrs } = (0, helpers_1.ariaSpec)(document.specs);
-                for (const attr of node.attributes) {
-                    const attrName = attr.getName().potential.trim().toLowerCase();
-                    if (/^aria-/i.test(attrName)) {
-                        const ariaAttr = ariaAttrs.find(attr => attr.name === attrName);
-                        if (ariaAttr && !ariaAttr.isGlobal) {
-                            report({
-                                scope: node,
-                                message: t('{0} is not {1}', t('the "{0*}" {1}', attrName, 'ARIA state/property'), 'global state/property'),
-                                line: attr.startLine,
-                                col: attr.startCol,
-                                raw: attr.raw,
-                            });
-                        }
-                    }
+            for (const attr of propAttrs) {
+                report((0, disallowed_prop_1.checkingDisallowedProp)({ attr, role: computed.role, propSpecs }));
+                if (el.rule.option.checkingDeprecatedProps) {
+                    report((0, deprecated_props_1.checkingDeprecatedProps)({ attr, role: computed.role, propSpecs }));
                 }
-            }
-            for (const attr of node.attributes) {
-                if (attr.attrType === 'html-attr' && attr.isDynamicValue) {
-                    continue;
+                if (el.rule.option.disallowSetImplicitProps) {
+                    const attrSpecs = (0, ml_core_1.getAttrSpecs)(el, document.specs);
+                    report((0, implicit_props_1.checkingImplicitProps)({ attr, propSpecs, attrSpecs }));
+                }
+                if (el.rule.option.checkingValue) {
+                    report((0, value_1.checkingValue)({ attr, role: computed.role, propSpecs }));
+                }
+                if (el.rule.option.disallowDefaultValue) {
+                    report((0, default_value_1.checkingDefaultValue)({ attr, propSpecs }));
                 }
-                const attrName = attr.getName().potential.trim().toLowerCase();
-                if (/^aria-/i.test(attrName)) {
-                    const value = attr.getValue().potential.trim().toLowerCase();
-                    const propSpec = ariaAttrs.find(p => p.name === attrName);
-                    // Checking ARIA Value
-                    if (node.rule.option.checkingValue) {
-                        const result = (0, helpers_1.checkAria)(document.specs, attrName, value, computedRole === null || computedRole === void 0 ? void 0 : computedRole.name);
-                        if (!result.isValid) {
-                            report({
-                                scope: node,
-                                message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0}"', value), 'disallowed'), t('the "{0*}" {1}', attrName, 'ARIA state/property')) +
-                                    ('enum' in result && result.enum.length
-                                        ? t('. ') + t('Allowed values are: {0}', t(result.enum))
-                                        : ''),
-                                line: attr.startLine,
-                                col: attr.startCol,
-                                raw: attr.raw,
-                            });
-                        }
-                    }
-                    // Checking implicit props
-                    if (node.rule.option.disallowSetImplicitProps) {
-                        if (propSpec && propSpec.equivalentHtmlAttrs) {
-                            for (const equivalentHtmlAttr of propSpec.equivalentHtmlAttrs) {
-                                const htmlAttrSpec = attrSpecs.find(a => a.name === equivalentHtmlAttr.htmlAttrName);
-                                const isValid = (0, helpers_1.isValidAttr)(t, equivalentHtmlAttr.htmlAttrName, equivalentHtmlAttr.value || '', false, node, attrSpecs);
-                                if (isValid && isValid.invalidType === 'non-existent') {
-                                    continue;
-                                }
-                                if (node.hasAttribute(equivalentHtmlAttr.htmlAttrName)) {
-                                    const targetAttrValue = node.getAttribute(equivalentHtmlAttr.htmlAttrName);
-                                    if ((equivalentHtmlAttr.value == null && targetAttrValue === value) ||
-                                        equivalentHtmlAttr.value === value) {
-                                        report({
-                                            scope: node,
-                                            message: t('{0} has {1}', t('the "{0*}" {1}', attrName, 'ARIA state/property'), t('the same {0} as {1}', 'semantics', t('{0} or {1}', t('the current "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute'), t('the implicit "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute')))),
-                                            line: attr.startLine,
-                                            col: attr.startCol,
-                                            raw: attr.raw,
-                                        });
-                                        continue;
-                                    }
-                                    if ((htmlAttrSpec === null || htmlAttrSpec === void 0 ? void 0 : htmlAttrSpec.type) === 'Boolean' && value !== 'false') {
-                                        continue;
-                                    }
-                                    report({
-                                        scope: node,
-                                        message: t('{0} contradicts {1}', t('the "{0*}" {1}', attrName, 'ARIA state/property'), t('the current "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute')),
-                                        line: attr.startLine,
-                                        col: attr.startCol,
-                                        raw: attr.raw,
-                                    });
-                                }
-                                else if (value === 'true') {
-                                    if (!equivalentHtmlAttr.isNotStrictEquivalent && (htmlAttrSpec === null || htmlAttrSpec === void 0 ? void 0 : htmlAttrSpec.type) === 'Boolean') {
-                                        report({
-                                            scope: node,
-                                            message: t('{0} contradicts {1}', t('the "{0*}" {1}', attrName, 'ARIA state/property'), t('the implicit "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute')),
-                                            line: attr.startLine,
-                                            col: attr.startCol,
-                                            raw: attr.raw,
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    // Default value
-                    if (node.rule.option.disallowDefaultValue && propSpec && propSpec.defaultValue === value) {
-                        report({
-                            scope: node,
-                            message: t('It is {0}', 'default value'),
-                            line: attr.startLine,
-                            col: attr.startCol,
-                            raw: attr.raw,
-                        });
-                    }
+                if (!computed.role) {
+                    report((0, no_global_prop_1.checkingNoGlobalProp)({ attr, propSpecs }));
                 }
             }
+            if (el.rule.option.checkingRequiredOwnedElements) {
+                report((0, required_owned_elements_1.checkingRequiredOwnedElements)({ el, role: computed.role }));
+            }
+            if (el.rule.option.checkingPresentationalChildren) {
+                report((0, presentational_children_1.checkingPresentationalChildren)({ el }));
+            }
+            if (el.rule.option.checkingInteractionInHidden) {
+                report((0, interaction_in_hidden_1.checkingInteractionInHidden)({ el }));
+            }
         });
     },
 });

package/lib/wai-aria/types.d.ts

@@ -0,0 +1,13 @@
+import type { ARIAVersion } from '@markuplint/ml-spec';
+export declare type Options = {
+    checkingValue: boolean;
+    checkingDeprecatedProps: boolean;
+    permittedAriaRoles: boolean;
+    checkingRequiredOwnedElements: boolean;
+    checkingPresentationalChildren: boolean;
+    checkingInteractionInHidden: boolean;
+    disallowSetImplicitRole: boolean;
+    disallowSetImplicitProps: boolean;
+    disallowDefaultValue: boolean;
+    version: ARIAVersion;
+};

package/lib/wai-aria/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "2.4.2",
+	"version": "3.0.0-alpha.0",
 	"description": "Rules for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -17,10 +17,10 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "2.7.0",
-		"@markuplint/ml-core": "2.3.2",
-		"@markuplint/ml-spec": "2.1.0",
-		"@markuplint/types": "2.1.0",
+		"@markuplint/html-spec": "3.0.0-alpha.0",
+		"@markuplint/ml-core": "3.0.0-alpha.0",
+		"@markuplint/ml-spec": "3.0.0-alpha.0",
+		"@markuplint/types": "3.0.0-alpha.0",
 		"debug": "^4.3.4",
 		"html-entities": "^2.3.3",
 		"tslib": "^2.3.1"
@@ -28,5 +28,5 @@
 	"devDependencies": {
 		"@types/debug": "^4.1.7"
 	},
-	"gitHead": "0c774ce046ebc8a9c494e9884a4bfcd72a66250d"
+	"gitHead": "d32c522e016888e20bcbb5f09352c006b964f193"
 }

package/schema.json

@@ -9,15 +9,6 @@
 				"attr-duplication": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-duplication/schema.json"
 				},
-				"attr-equal-space-after": {
-					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-equal-space-after/schema.json"
-				},
-				"attr-equal-space-before": {
-					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-equal-space-before/schema.json"
-				},
-				"attr-spacing": {
-					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-spacing/schema.json"
-				},
 				"attr-value-quotes": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/attr-value-quotes/schema.json"
 				},
@@ -51,9 +42,6 @@
 				"end-tag": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/end-tag/schema.json"
 				},
-				"indentation": {
-					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/indentation/schema.json"
-				},
 				"ineffective-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/ineffective-attr/schema.json"
 				},