@mrhenry/stylelint-mrhenry-attribute-selector-no-unknown 2.0.1 → 2.1.0

package/index.mjs

@@ -1,6 +1,7 @@
 import stylelint from 'stylelint';
 import selectorParser from 'postcss-selector-parser';
 import { data } from './data.mjs';
+import { isRecordOfStringArrays, isString } from './validate-options.mjs';
 
 const ruleName = "@mrhenry/stylelint-mrhenry-attribute-selector-no-unknown";
 const messages = stylelint.utils.ruleMessages(ruleName, {
@@ -27,7 +28,34 @@ const ruleFunction = (primaryOption, secondaryOption, context) => {
 
 		/* c8 ignore next */
 		if (!validPrimary) return;
-		
+
+		const validSecondary = stylelint.utils.validateOptions(postcssResult, ruleName, {
+			actual: secondaryOption,
+			possible: {
+				globalAttributes: [isString],
+				attributesByTagName: isRecordOfStringArrays,
+			},
+			optional: true,
+		});
+
+		/* c8 ignore next */
+		if (!validSecondary) return;
+
+		const userData = {
+			/** @type {Set<string>} */
+			globalAttributes: new Set(secondaryOption?.globalAttributes ?? []),
+			/** @type {Map<string, string[]>} */
+			attributesByTagName: new Map(Object.entries(secondaryOption?.attributesByTagName ?? {})),
+			/** @type {Set<string>} */
+			allAttributes: new Set(secondaryOption?.globalAttributes ?? []),
+		}
+
+		for (const attributes of userData.attributesByTagName.values()) {
+			for (const attribute of attributes) {
+				userData.allAttributes.add(attribute);
+			}
+		}
+
 		postcssRoot.walkRules((rule) => {
 			if (!rule.selector.includes('[')) {
 				return;
@@ -46,8 +74,12 @@ const ruleFunction = (primaryOption, secondaryOption, context) => {
 
 				// Global attributes are always allowed.
 				if (data.globalAttributes.has(attribute)) return;
+				if (userData.globalAttributes.has(attribute)) return;
 
-				if (!data.allAttributes.has(attribute)) {
+				if (
+					!data.allAttributes.has(attribute) &&
+					!userData.allAttributes.has(attribute)
+				) {
 					// An unknown attribute that doesn't start with "data-" is always invalid.
 					stylelint.utils.report({
 						message: messages.expected,
@@ -64,13 +96,16 @@ const ruleFunction = (primaryOption, secondaryOption, context) => {
 
 				const tagName = findTagNameInCompound(node);
 				if (!tagName) {
-					// Without a tagname we assime that any attribute is allowed.
+					// Without a tagname we assume that any attribute is allowed.
 					return;
 				}
 
 				const attributesByTagName = data.attributesByTagName.get(tagName);
 				if (attributesByTagName && attributesByTagName.includes(attribute)) return;
 
+				const userAttributesByTagName = userData.attributesByTagName.get(tagName);
+				if (userAttributesByTagName && userAttributesByTagName.includes(attribute)) return;
+
 				// If the tag name is a standard element
 				// we assume that only attributes that are valid for that tag are allowed.
 				stylelint.utils.report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrhenry/stylelint-mrhenry-attribute-selector-no-unknown",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Warn when unknown attribute selectors are used",
   "type": "module",
   "main": "index.mjs",
@@ -18,6 +18,7 @@
   "files": [
     "index.mjs",
     "data.mjs",
+    "validate-options.mjs",
     "LICENSE",
     "README.md"
   ],
@@ -26,12 +27,12 @@
     "stylelint-plugin"
   ],
   "dependencies": {
-    "postcss-selector-parser": "^6.0.11"
+    "postcss-selector-parser": "^6.0.15"
   },
   "peerDependencies": {
     "stylelint": "^16.0.0"
   },
   "devDependencies": {
-    "stylelint": "^16.0.2"
+    "stylelint": "^16.1.0"
   }
 }

package/validate-options.mjs

@@ -0,0 +1,25 @@
+export function isString(value) {
+	return typeof value === 'string' || value instanceof String;
+}
+
+export function isRecordOfStringArrays(value) {
+	if (!value) return false;
+	if (typeof value !== 'object') return false;
+	if (Array.isArray(value)) return false;
+
+	for (const key in value) {
+		if (Object.hasOwnProperty.call(value, key)) {
+			/* c8 ignore next */
+			if (!isString(key)) return false;
+
+			if (!value[key]) return false;
+			if (!Array.isArray(value[key])) return false;
+
+			for (const attr of value[key]) {
+				if (!isString(attr)) return false;
+			}
+		}
+	}
+
+	return true;
+}