@markuplint/rules 3.0.0-canary.3 → 3.0.0-dev.176

package/lib/wai-aria/index.js

@@ -1,6 +1,7 @@
 "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 default_value_1 = require("./checkings/default-value");
@@ -27,7 +28,7 @@ exports.default = (0, ml_core_1.createRule)({
         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 => {
@@ -47,8 +48,8 @@ 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_existent_role_1.checkingNonExistentRole)({ attr: roleAttr }))) {
                     return;
@@ -57,39 +58,39 @@ exports.default = (0, ml_core_1.createRule)({
                     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) {
+                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) {
+            if (el.rule.options.checkingRequiredOwnedElements) {
                 report((0, required_owned_elements_1.checkingRequiredOwnedElements)({ el, role: computed.role }));
             }
-            if (el.rule.option.checkingPresentationalChildren) {
+            if (el.rule.options.checkingPresentationalChildren) {
                 report((0, presentational_children_1.checkingPresentationalChildren)({ el }));
             }
-            if (el.rule.option.checkingInteractionInHidden) {
+            if (el.rule.options.checkingInteractionInHidden) {
                 report((0, interaction_in_hidden_1.checkingInteractionInHidden)({ el }));
             }
         });

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

@@ -1,13 +1,13 @@
 import type { ARIAVersion } from '@markuplint/ml-spec';
 export type Options = {
-    checkingValue: boolean;
-    checkingDeprecatedProps: boolean;
-    permittedAriaRoles: boolean;
-    checkingRequiredOwnedElements: boolean;
-    checkingPresentationalChildren: boolean;
-    checkingInteractionInHidden: boolean;
-    disallowSetImplicitRole: boolean;
-    disallowSetImplicitProps: boolean;
-    disallowDefaultValue: boolean;
-    version: ARIAVersion;
+	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,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "3.0.0-canary.3+382d1365",
+	"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>",
@@ -16,18 +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-canary.5+382d1365",
-		"@markuplint/ml-core": "3.0.0-canary.5+382d1365",
-		"@markuplint/ml-spec": "3.0.0-canary.5+382d1365",
-		"@markuplint/types": "3.0.0-canary.5+382d1365",
+		"@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.4.0"
-	},
-	"devDependencies": {
-		"@types/debug": "^4.1.7"
+		"tslib": "^2.4.1",
+		"type-fest": "^3.8.0"
 	},
-	"gitHead": "382d13653071bd02210d5430403d1a87c840398c"
+	"gitHead": "f6ad62e992e1569be4067f1e90d2d6017a658f57"
 }

package/schema.json

@@ -75,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',
+		},
+	]);
+});

package/test/attr-duplication/index.spec.js

@@ -0,0 +1,159 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/attr-duplication').default;
+
+test('is test 1', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+	);
+
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 2,
+			col: 26,
+			raw: 'data-Attr',
+		},
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 2,
+			col: 41,
+			raw: 'data-attR',
+		},
+	]);
+});
+
+test('is test 2', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		`
+		<div
+			data-attr="value"
+			data-Attr='db'
+			data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+	);
+
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 4,
+			col: 4,
+			raw: 'data-Attr',
+		},
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 5,
+			col: 4,
+			raw: 'data-attR',
+		},
+	]);
+});
+
+test('is test 3', async () => {
+	const { violations } = await mlRuleTest(rule, '<img src="/" SRC="/" >', undefined, false, 'ja');
+
+	expect(violations.map(_ => _.message)).toStrictEqual(['属性名が重複しています']);
+});
+
+test('nodeRules disable', async () => {
+	const { violations } = await mlRuleTest(rule, '<div><span attr attr></span></div>', {
+		nodeRule: [
+			{
+				selector: 'span',
+				rule: false,
+			},
+		],
+	});
+
+	expect(violations.length).toStrictEqual(0);
+});
+
+test('Vue', async () => {
+	const { violations } = await mlRuleTest(rule, '<template><div attr v-bind:attr /></template>', {
+		parser: {
+			'.*': '@markuplint/vue-parser',
+		},
+	});
+
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 21,
+			message: 'The attribute name is duplicated',
+			raw: 'v-bind:attr',
+		},
+	]);
+});
+
+test('Vue (exception)', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		'<template><div class="foo" v-bind:class="bar" style="a: b;" :style="{c: d}" /></template>',
+		{
+			parser: {
+				'.*': '@markuplint/vue-parser',
+			},
+		},
+	);
+
+	expect(violations.length).toBe(0);
+});
+
+test('React', async () => {
+	const { violations } = await mlRuleTest(rule, '<div tabindex tabIndex />', {
+		parser: {
+			'.*': '@markuplint/vue-parser',
+		},
+	});
+
+	expect(violations).toStrictEqual([]);
+});
+
+test('Pug', async () => {
+	const { violations } = await mlRuleTest(rule, '.hoge(class="hoge2")&attributes({class: "hoge3"})', {
+		parser: {
+			'.*': '@markuplint/pug-parser',
+		},
+	});
+
+	expect(violations.length).toBe(0);
+});
+
+test('Svelte', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		'<div class:selected="{isSelected}" class:focused="{isFocused}"></div>',
+		{
+			parser: {
+				'.*': '@markuplint/svelte-parser',
+			},
+		},
+	);
+
+	expect(violations.length).toBe(0);
+});
+
+test('Astro', async () => {
+	const { violations } = await mlRuleTest(rule, '<div class:list="a" class="b"></div>', {
+		parser: {
+			'.*': '@markuplint/astro-parser',
+		},
+	});
+
+	expect(violations.length).toBe(1);
+});

package/test/attr-value-quotes/index.spec.js

@@ -0,0 +1,133 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/attr-value-quotes').default;
+
+describe('verify', () => {
+	test('default', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+		);
+		expect(violations).toStrictEqual([
+			{
+				severity: 'warning',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 26,
+				raw: "data-Attr='db'",
+			},
+			{
+				severity: 'warning',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 41,
+				raw: 'data-attR=tr',
+			},
+		]);
+	});
+
+	test('double', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+			{
+				rule: {
+					severity: 'error',
+					value: 'double',
+					options: null,
+				},
+			},
+		);
+		expect(violations).toStrictEqual([
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 26,
+				raw: "data-Attr='db'",
+			},
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 41,
+				raw: 'data-attR=tr',
+			},
+		]);
+	});
+
+	test('single', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+			{
+				rule: {
+					severity: 'error',
+					value: 'single',
+					options: null,
+				},
+			},
+		);
+		expect(violations).toStrictEqual([
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on single quotation mark',
+				line: 2,
+				col: 8,
+				raw: 'data-attr="value"',
+			},
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on single quotation mark',
+				line: 2,
+				col: 41,
+				raw: 'data-attR=tr',
+			},
+		]);
+	});
+
+	test('empty', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+		);
+		expect(violations.length).toBe(0);
+	});
+});
+
+// describe('fix', () => {
+// 	test('empty', async () => {
+// 		const { fixedCode } = await mlRuleTest(rule, '<div attr noop=noop foo="bar" hoge=\'fuga\'>', undefined, true);
+// 		expect(fixedCode).toEqual('<div attr noop="noop" foo="bar" hoge="fuga">');
+// 	});
+
+// 	test('empty', async () => {
+// 		const { fixedCode } = await mlRuleTest(
+// 			rule,
+// 			'<div attr noop=noop foo="bar" hoge=\'fuga\'>',
+// 			{ rule: 'single' },
+// 			true,
+// 		);
+// 		expect(fixedCode).toEqual("<div attr noop='noop' foo='bar' hoge='fuga'>");
+// 	});
+// });

package/test/case-sensitive-attr-name/index.spec.js

@@ -0,0 +1,65 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/case-sensitive-attr-name').default;
+
+describe('verify', () => {
+	test('lower case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-lowercase></div>');
+		expect(violations).toStrictEqual([]);
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-UPPERCASE="value"></div>');
+		expect(violations[0].severity).toBe('warning');
+		expect(violations[0].message).toBe('Attribute names of HTML elements should be lowercase');
+		expect(violations[0].raw).toBe('data-UPPERCASE');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-UPPERCASE="value"></div>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+				options: null,
+			},
+		});
+		expect(violations[0].severity).toBe('error');
+		expect(violations[0].message).toBe('Attribute names of HTML elements must be uppercase');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-uppercase="value"></div>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+				options: null,
+			},
+		});
+		expect(violations[0].severity).toBe('error');
+		expect(violations[0].message).toBe('Attribute names of HTML elements must be uppercase');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div DATA-UPPERCASE="value"></div>', {
+			rule: { severity: 'error', value: 'upper' },
+		});
+		expect(violations.length).toBe(0);
+	});
+
+	test('svg', async () => {
+		const { violations } = await mlRuleTest(rule, '<svg viewBox="0 0 100 100"></svg>');
+		expect(violations.length).toBe(0);
+	});
+});
+
+// describe('fix', () => {
+// 	test('upper case', async () => {
+// 		const { fixedCode } = await mlRuleTest(rule, '<DIV DATA-LOWERCASE></DIV>', undefined, true);
+// 		expect(fixedCode).toBe('<DIV data-lowercase></DIV>');
+// 	});
+
+// 	test('upper case', async () => {
+// 		const { fixedCode } = await mlRuleTest(rule, '<DIV data-lowercase></DIV>', { rule: 'upper' }, true);
+// 		expect(fixedCode).toBe('<DIV DATA-LOWERCASE></DIV>');
+// 	});
+// });