@markuplint/rules 3.0.0-alpha.66 → 3.0.0-dev.176

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

@@ -0,0 +1,103 @@
+"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 === 0) {
+        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`
+    const children = Array.from(el.childNodes).map(child => {
+        if (child.is(child.ELEMENT_NODE)) {
+            if (child.matches('[aria-busy="true" i]')) {
+                return [child, 'BUSY'];
+            }
+            const computedChild = (0, ml_spec_1.getComputedRole)(child.ownerMLDocument.specs, child, child.rule.options.version);
+            if (role.requiredOwnedElements.some(ownedRole => (0, ml_spec_1.isRequiredOwnedElement)(computedChild.el, computedChild.role, ownedRole, child.ownerMLDocument.specs, child.rule.options.version))) {
+                return [child, 'REQUIRED'];
+            }
+            return [child, 'OTHER'];
+        }
+        else if (child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+            return [child, 'PB'];
+        }
+        return [null, 'NO_ELEMENT'];
+    });
+    if (children.some(([, type]) => type === 'BUSY')) {
+        return;
+    }
+    /**
+     * > Any element that will be owned by the element with this role.
+     * > For example, an element with the role list
+     * > **will own at least one element** with the role listitem.
+     */
+    if (children.some(([, type]) => type === 'REQUIRED')) {
+        return;
+    }
+    if (children.some(([, type]) => type === 'PB')) {
+        // TODO: https://github.com/markuplint/markuplint/issues/490
+        return;
+    }
+    /**
+     * Has mutable children
+     *
+     * Ex:
+     *
+     * ```jsx
+     * <table>
+     *   <tbody>
+     *     {list.map((item) => <tr><td>{item}</td></tr>)}
+     *   </tbody>
+     * </table>
+     * ```
+     */
+    if (el.hasMutableChildren(true)) {
+        return;
+    }
+    if (mayBeBeforeCreated(el)) {
+        return {
+            scope: el,
+            message: t('{0}. Or, {1}', t('require {0}', role.requiredOwnedElements.length === 1 && role.requiredOwnedElements[0]
+                ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
+                : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`), t('require {0}', 'aria-busy="true"')),
+        };
+    }
+    return {
+        scope: el,
+        message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), role.requiredOwnedElements.length === 1 && role.requiredOwnedElements[0]
+            ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
+            : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`),
+    };
+};
+exports.checkingRequiredOwnedElements = checkingRequiredOwnedElements;
+function mayBeBeforeCreated(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    if (el.isEmpty()) {
+        return true;
+    }
+    return Array.from(el.children).every(child => {
+        return ['script', 'template'].includes(child.localName);
+    });
+}

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

@@ -0,0 +1,15 @@
+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: readonly ARIAProperty[];
+	}
+>;

package/lib/wai-aria/checkings/required-prop copy.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/required-prop.d.ts

@@ -1,9 +1,15 @@
 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[];
-}>;
+export declare const checkingRequiredProp: ElementChecker<
+	boolean,
+	Options,
+	{
+		role?:
+			| (ARIARole & {
+					isImplicit?: boolean;
+			  })
+			| null;
+		propSpecs: readonly ARIAProperty[];
+	}
+>;

package/lib/wai-aria/checkings/unadopted-explicit-roles.d.ts

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

package/lib/wai-aria/checkings/unadopted-explicit-roles.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkingUnadoptedExplicitRoles = void 0;
+const checkingUnadoptedExplicitRoles = ({ el, role, propSpecs }) => t => {
+    if (!role) {
+        return;
+    }
+    if (role.name) {
+        console.log(el.localName, role.name);
+        return {
+            scope: el,
+            message: '',
+        };
+    }
+    return;
+};
+exports.checkingUnadoptedExplicitRoles = checkingUnadoptedExplicitRoles;

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

@@ -1,7 +1,22 @@
 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[];
-}>;
+export declare const checkingValue: AttrChecker<
+	boolean,
+	Options,
+	{
+		role?: ARIARole | null;
+		propSpecs: readonly ARIAProperty[];
+		booleanish?: boolean;
+	}
+>;
+/**
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ */
+export declare function checkAriaValue(
+	type: string,
+	value: string,
+	tokenEnum: readonly string[],
+	booleanish?: boolean,
+): boolean;

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

@@ -1,21 +1,93 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkingValue = void 0;
-const helpers_1 = require("../../helpers");
-const checkingValue = ({ attr, role, propSpecs }) => t => {
+exports.checkAriaValue = exports.checkingValue = void 0;
+const checkingValue = ({ attr, role, propSpecs, booleanish }) => 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);
+    const result = checkAria(propSpec, attr.value, role === null || role === void 0 ? void 0 : role.name, booleanish);
     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)) : ''),
+            ('enum' in result && result.enum.length > 0
+                ? t('. ') + t('Allowed values are: {0}', t(result.enum))
+                : ''),
     };
 };
 exports.checkingValue = checkingValue;
+function checkAria(propSpec, currentValue, role, booleanish) {
+    if (!propSpec) {
+        return {
+            currentValue,
+            // For skipping checking
+            isValid: true,
+        };
+    }
+    let valueType = propSpec.value;
+    if (role && propSpec.conditionalValue) {
+        for (const cond of propSpec.conditionalValue) {
+            if (cond.role.includes(role)) {
+                valueType = cond.value;
+                break;
+            }
+        }
+    }
+    const isValid = checkAriaValue(valueType, currentValue, propSpec.enum, booleanish);
+    return {
+        ...propSpec,
+        currentValue,
+        isValid,
+    };
+}
+/**
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ */
+function checkAriaValue(type, value, tokenEnum, booleanish) {
+    switch (type) {
+        case 'token': {
+            return tokenEnum.includes(value);
+        }
+        case 'token list': {
+            const list = value.split(/\s+/g).map(s => s.trim());
+            return list.every(token => tokenEnum.includes(token));
+        }
+        case 'string':
+        case 'ID reference':
+        case 'ID reference list': {
+            return true;
+        }
+        case 'true/false': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['true', 'false'].includes(value);
+        }
+        case 'tristate': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['mixed', 'true', 'false', 'undefined'].includes(value);
+        }
+        case 'true/false/undefined': {
+            if (booleanish && value === '') {
+                return true;
+            }
+            return ['true', 'false', 'undefined'].includes(value);
+        }
+        case 'integer': {
+            return parseInt(value).toString() === value;
+        }
+        case 'number': {
+            return parseFloat(value).toString() === value;
+        }
+    }
+    // For skipping checking
+    return true;
+}
+exports.checkAriaValue = checkAriaValue;

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

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

package/lib/wai-aria/index.js

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
+const ml_spec_1 = require("@markuplint/ml-spec");
 const helpers_1 = require("../helpers");
 const abstract_role_1 = require("./checkings/abstract-role");
-const checking_required_owned_elements_1 = require("./checkings/checking-required-owned-elements");
 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 non_existent_role_1 = require("./checkings/non-existent-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)({
@@ -20,17 +23,19 @@ exports.default = (0, ml_core_1.createRule)({
         checkingDeprecatedProps: true,
         permittedAriaRoles: true,
         checkingRequiredOwnedElements: true,
+        checkingPresentationalChildren: false,
+        checkingInteractionInHidden: false,
         disallowSetImplicitRole: true,
         disallowSetImplicitProps: true,
         disallowDefaultValue: false,
-        version: '1.2',
+        version: ml_spec_1.ARIA_RECOMMENDED_VERSION,
     },
     async verify({ document, report, t }) {
         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);
+            const elSpec = (0, ml_core_1.getSpec)(el, document.specs.specs);
             if (!elSpec) {
                 return;
             }
@@ -43,44 +48,50 @@ exports.default = (0, ml_core_1.createRule)({
                 }
                 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);
+            const computed = (0, ml_core_1.getComputedRole)(document.specs, el, el.rule.options.version);
+            const { props: propSpecs } = (0, ml_core_1.ariaSpecs)(document.specs, el.rule.options.version);
             if (roleAttr) {
-                if (report((0, non_existant_role_1.checkingNonExistantRole)({ attr: roleAttr }))) {
+                if (report((0, non_existent_role_1.checkingNonExistentRole)({ attr: roleAttr }))) {
                     return;
                 }
                 if (report((0, abstract_role_1.checkingAbstractRole)({ attr: roleAttr }))) {
                     return;
                 }
                 report((0, required_prop_1.checkingRequiredProp)({ el, role: computed.role, propSpecs }));
-                if (el.rule.option.disallowSetImplicitRole) {
+                if (el.rule.options.disallowSetImplicitRole) {
                     report((0, implicit_role_1.checkingImplicitRole)({ attr: roleAttr }));
                 }
-                if (el.rule.option.permittedAriaRoles) {
+                if (el.rule.options.permittedAriaRoles) {
                     report((0, permitted_roles_1.checkingPermittedRoles)({ attr: roleAttr }));
                 }
             }
             for (const attr of propAttrs) {
                 report((0, disallowed_prop_1.checkingDisallowedProp)({ attr, role: computed.role, propSpecs }));
-                if (el.rule.option.checkingDeprecatedProps) {
+                if (el.rule.options.checkingDeprecatedProps) {
                     report((0, deprecated_props_1.checkingDeprecatedProps)({ attr, role: computed.role, propSpecs }));
                 }
-                if (el.rule.option.disallowSetImplicitProps) {
+                if (el.rule.options.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.options.checkingValue) {
+                    report((0, value_1.checkingValue)({ attr, role: computed.role, propSpecs, booleanish: document.booleanish }));
                 }
-                if (el.rule.option.disallowDefaultValue) {
+                if (el.rule.options.disallowDefaultValue) {
                     report((0, default_value_1.checkingDefaultValue)({ attr, propSpecs }));
                 }
                 if (!computed.role) {
                     report((0, no_global_prop_1.checkingNoGlobalProp)({ attr, propSpecs }));
                 }
             }
-            if (el.rule.option.checkingRequiredOwnedElements) {
-                report((0, checking_required_owned_elements_1.checkingRequiredOwnedElements)({ el, role: computed.role }));
+            if (el.rule.options.checkingRequiredOwnedElements) {
+                report((0, required_owned_elements_1.checkingRequiredOwnedElements)({ el, role: computed.role }));
+            }
+            if (el.rule.options.checkingPresentationalChildren) {
+                report((0, presentational_children_1.checkingPresentationalChildren)({ el }));
+            }
+            if (el.rule.options.checkingInteractionInHidden) {
+                report((0, interaction_in_hidden_1.checkingInteractionInHidden)({ el }));
             }
         });
     },

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

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

package/lib/xxx/index.d.ts

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

package/lib/xxx/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ml_core_1 = require("@markuplint/ml-core");
+exports.default = (0, ml_core_1.createRule)({
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        // Element
+        await document.walkOn("Element", (el) => {
+            const raw = el.raw.trim();
+            if (/./i.test(raw)) {
+                report({
+                    scope: el,
+                    message: t("It is {0}", "issue"),
+                });
+            }
+        });
+        // Attribute
+        await document.walkOn("Attr", (attr) => {
+            var _a, _b, _c;
+            if (/./i.test(attr.name)) {
+                report({
+                    scope: attr,
+                    line: (_a = attr.nameNode) === null || _a === void 0 ? void 0 : _a.startLine,
+                    col: (_b = attr.nameNode) === null || _b === void 0 ? void 0 : _b.startCol,
+                    raw: (_c = attr.nameNode) === null || _c === void 0 ? void 0 : _c.raw,
+                    message: t("It is {0}", "issue"),
+                });
+            }
+        });
+    },
+});

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@markuplint/rules",
-	"version": "3.0.0-alpha.66+6cde1134",
-	"description": "Rules for markuplint",
+	"version": "3.0.0-dev.176+f6ad62e9",
+	"description": "Built-in rules of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
@@ -16,17 +16,23 @@
 		"dev": "tsc --build --watch",
 		"clean": "tsc --build --clean"
 	},
+	"browser": {
+		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
+	},
 	"dependencies": {
-		"@markuplint/html-spec": "3.0.0-alpha.66+6cde1134",
-		"@markuplint/ml-core": "3.0.0-alpha.66+6cde1134",
-		"@markuplint/ml-spec": "3.0.0-alpha.82+6cde1134",
-		"@markuplint/types": "2.1.0",
+		"@markuplint/html-spec": "3.0.0-dev.176+f6ad62e9",
+		"@markuplint/ml-core": "3.0.0-dev.176+f6ad62e9",
+		"@markuplint/ml-spec": "3.0.0-dev.176+f6ad62e9",
+		"@markuplint/selector": "3.0.0-dev.176+f6ad62e9",
+		"@markuplint/shared": "3.5.1-dev.3129+f6ad62e9",
+		"@markuplint/types": "3.0.0-dev.176+f6ad62e9",
+		"@types/debug": "^4.1.7",
+		"@ungap/structured-clone": "^1.0.1",
+		"ansi-colors": "^4.1.3",
+		"chrono-node": "^2.5.0",
 		"debug": "^4.3.4",
-		"html-entities": "^2.3.3",
-		"tslib": "^2.3.1"
-	},
-	"devDependencies": {
-		"@types/debug": "^4.1.7"
+		"tslib": "^2.4.1",
+		"type-fest": "^3.8.0"
 	},
-	"gitHead": "6cde113402758a8fdbd6a0fcf98e78efd2cdb778"
+	"gitHead": "f6ad62e992e1569be4067f1e90d2d6017a658f57"
 }

package/schema.json

@@ -48,6 +48,9 @@
 				"invalid-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/invalid-attr/schema.json"
 				},
+				"label-has-control": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/label-has-control/schema.json"
+				},
 				"landmark-roles": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/landmark-roles/schema.json"
 				},
@@ -57,6 +60,9 @@
 				"no-default-value": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-default-value/schema.json"
 				},
+				"no-empty-palpable-content": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-empty-palpable-content/schema.json"
+				},
 				"no-hard-code-id": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-hard-code-id/schema.json"
 				},
@@ -69,9 +75,15 @@
 				"permitted-contents": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/permitted-contents/schema.json"
 				},
+				"placeholder-label-option": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/placeholder-label-option/schema.json"
+				},
 				"require-accessible-name": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/require-accessible-name/schema.json"
 				},
+				"require-datetime": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/require-datetime/schema.json"
+				},
 				"required-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/required-attr/schema.json"
 				},

package/test/attr-check.spec.js

@@ -0,0 +1,77 @@
+const { translator } = require('@markuplint/i18n');
+const { i18n } = require('markuplint');
+
+const { valueCheck } = require('../lib/attr-check');
+
+let t;
+
+beforeAll(async () => {
+	const locale = await i18n('en');
+	t = translator(locale);
+});
+
+test('OneCodePointChar List', () => {
+	expect(
+		valueCheck(t, 'accesskey', '@ 12', {
+			token: 'OneCodePointChar',
+			separator: 'space',
+			unique: true,
+		}),
+	).toStrictEqual([
+		'the "accesskey" attribute expects space-separated list. the the content of the list part includes unexpected characters. It expects one code point character (https://html.spec.whatwg.org/multipage/interaction.html#the-accesskey-attribute)',
+		{
+			col: 2,
+			line: 0,
+			raw: '12',
+		},
+	]);
+});
+
+test('BrowsingContextNameOrKeyword', () => {
+	expect(valueCheck(t, 'target', '', 'BrowsingContextNameOrKeyword')).toStrictEqual([
+		'the "target" attribute must not be empty. It expects either "_blank", "_self", "_parent", "_top", "browsing context name" (https://html.spec.whatwg.org/multipage/browsers.html#valid-browsing-context-name-or-keyword)',
+		{
+			col: 0,
+			line: 0,
+			raw: '',
+		},
+	]);
+});
+
+test('BCP47', () => {
+	expect(valueCheck(t, 'lang', '', 'BCP47')).toStrictEqual([
+		'the "lang" attribute must not be empty. It expects the BCP47 format (https://tools.ietf.org/rfc/bcp/bcp47.html)',
+		{
+			col: 0,
+			line: 0,
+			raw: '',
+		},
+	]);
+});
+
+test('DateTime', () => {
+	expect(valueCheck(t, 'datetime', '200-1-1', 'DateTime')).toStrictEqual([
+		'the year part of the "datetime" attribute expects four or more digits (https://html.spec.whatwg.org/multipage/text-level-semantics.html#datetime-value)',
+		{
+			col: 0,
+			line: 0,
+			raw: '200',
+		},
+	]);
+	expect(valueCheck(t, 'datetime', '2000-1-1', 'DateTime')).toStrictEqual([
+		'the month part of the "datetime" attribute expects two digits (https://html.spec.whatwg.org/multipage/text-level-semantics.html#datetime-value)',
+		{
+			col: 5,
+			line: 0,
+			raw: '1',
+		},
+	]);
+	expect(valueCheck(t, 'datetime', '00:00:00.0000', 'DateTime')).toStrictEqual([
+		'the fractional part part of the "datetime" attribute expects one to three digits (https://html.spec.whatwg.org/multipage/text-level-semantics.html#datetime-value)',
+		{
+			col: 9,
+			line: 0,
+			raw: '0000',
+		},
+	]);
+});