@markuplint/rules 2.4.3 → 3.0.0-alpha.1

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.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.3",
+	"version": "3.0.0-alpha.1",
 	"description": "Rules for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -17,16 +17,17 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "2.8.0",
-		"@markuplint/ml-core": "2.3.3",
-		"@markuplint/ml-spec": "2.1.1",
-		"@markuplint/types": "2.2.0",
+		"@markuplint/html-spec": "3.0.0-alpha.1",
+		"@markuplint/ml-core": "3.0.0-alpha.1",
+		"@markuplint/ml-spec": "3.0.0-alpha.1",
+		"@markuplint/types": "3.0.0-alpha.1",
+		"@ungap/structured-clone": "^1.0.1",
 		"debug": "^4.3.4",
 		"html-entities": "^2.3.3",
-		"tslib": "^2.3.1"
+		"tslib": "^2.4.0"
 	},
 	"devDependencies": {
 		"@types/debug": "^4.1.7"
 	},
-	"gitHead": "c28258b756d8c42890698e26c03cdc02c6833489"
+	"gitHead": "56de89456146a06777eb5b6d4e8ba456147dd18b"
 }

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"
 				},