eslint-plugin-svg 0.0.4 → 0.0.5

package/README.md

@@ -53,6 +53,11 @@ export default defineConfig([
 | [no-empty-desc](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-desc)           | Disallow empty desc element              | ✅  |     |     |
 | [no-empty-text](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-text)           | Disallow empty text element              | ✅  |     |     |
 | [no-empty-container](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-container) | Disallow empty container element         | ✅  |     |     |
+| [no-empty-groups](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-groups)       | Disallow empty g element                 | ✅  |     |     |
+| [no-inline-styles](https://eslint-plugin-svg.ntnyq.com/rules/no-inline-styles)     | Disallow inline style attribute          | ✅  |     |     |
+| [no-event-handlers](https://eslint-plugin-svg.ntnyq.com/rules/no-event-handlers)   | Disallow inline event handlers           | ✅  |     |     |
+| [no-script-tags](https://eslint-plugin-svg.ntnyq.com/rules/no-script-tags)         | Disallow script elements                 | ✅  |     |     |
+| [require-viewbox](https://eslint-plugin-svg.ntnyq.com/rules/require-viewbox)       | Require viewBox on svg elements          | ✅  |     |     |
 | [no-deprecated](https://eslint-plugin-svg.ntnyq.com/rules/no-deprecated)           | Disallow deprecated elements             | ✅  |     |     |
 | [no-elements](https://eslint-plugin-svg.ntnyq.com/rules/no-elements)               | Disallow elements by name                |     |     |     |
 | [no-doctype](https://eslint-plugin-svg.ntnyq.com/rules/no-doctype)                 | Disallow doctype                         | ✅  | 🔧  |     |

package/dist/index.d.ts

@@ -165,23 +165,28 @@ type SVGSettings = {
 };
 //#endregion
 //#region src/rules/no-deprecated.d.ts
-type Options$3 = [{
+type Options$4 = [{
   allowElements?: string[];
 }];
 //#endregion
 //#region src/rules/no-elements.d.ts
-type Options$2 = [{
+type Options$3 = [{
   elements?: string[];
 }];
 //#endregion
 //#region src/rules/no-empty-container.d.ts
-type Options$1 = [{
+type Options$2 = [{
   elements?: string[];
   ignores?: string[];
   ignoreComments?: boolean;
   ignoreWhitespace?: boolean;
 }];
 //#endregion
+//#region src/rules/no-event-handlers.d.ts
+type Options$1 = [{
+  ignores?: string[];
+}];
+//#endregion
 //#region src/rules/no-invalid-role.d.ts
 type Options = [{
   roles?: string[];
@@ -189,14 +194,19 @@ type Options = [{
 //#endregion
 //#region src/rules/index.d.ts
 declare const rules: {
-  'no-deprecated': RuleModule<"deprecatedElement", Options$3, unknown>;
+  'no-deprecated': RuleModule<"deprecatedElement", Options$4, unknown>;
   'no-doctype': RuleModule<"invalid", [], unknown>;
-  'no-elements': RuleModule<"invalid", Options$2, unknown>;
-  'no-empty-container': RuleModule<"invalid", Options$1, unknown>;
+  'no-elements': RuleModule<"invalid", Options$3, unknown>;
+  'no-empty-container': RuleModule<"invalid", Options$2, unknown>;
   'no-empty-desc': RuleModule<"invalid", [], unknown>;
+  'no-empty-groups': RuleModule<"invalid", [], unknown>;
   'no-empty-text': RuleModule<"invalid", [], unknown>;
   'no-empty-title': RuleModule<"invalid", [], unknown>;
+  'no-event-handlers': RuleModule<"invalid", Options$1, unknown>;
+  'no-inline-styles': RuleModule<"invalid", [], unknown>;
   'no-invalid-role': RuleModule<"invalid", Options, unknown>;
+  'no-script-tags': RuleModule<"invalid", [], unknown>;
+  'require-viewbox': RuleModule<"missing", [], unknown>;
 };
 //#endregion
 //#region src/types/plugin.d.ts

package/dist/index.js

@@ -1,6 +1,6 @@
 import * as parserSVG from "svg-eslint-parser";
 import "uncase";
-import { isNonEmptyString } from "@ntnyq/utils";
+import { isNonEmptyString, toArray } from "@ntnyq/utils";
 
 //#region src/configs/index.ts
 /**
@@ -18,9 +18,14 @@ const recommended = [{
 		"svg/no-doctype": "error",
 		"svg/no-empty-container": "error",
 		"svg/no-empty-desc": "error",
+		"svg/no-empty-groups": "error",
 		"svg/no-empty-text": "error",
 		"svg/no-empty-title": "error",
-		"svg/no-invalid-role": "error"
+		"svg/no-event-handlers": "error",
+		"svg/no-inline-styles": "error",
+		"svg/no-invalid-role": "error",
+		"svg/no-script-tags": "error",
+		"svg/require-viewbox": "error"
 	}
 }];
 const configs = { recommended };
@@ -28,7 +33,7 @@ const configs = { recommended };
 //#endregion
 //#region package.json
 var name = "eslint-plugin-svg";
-var version = "0.0.4";
+var version = "0.0.5";
 
 //#endregion
 //#region src/meta.ts
@@ -264,21 +269,21 @@ function deepMerge(first = {}, second = {}) {
 
 //#endregion
 //#region src/utils/createRule.ts
-function createRule({ create, defaultOptions: defaultOptions$4, meta: meta$1 }) {
+function createRule({ create, defaultOptions: defaultOptions$5, meta: meta$1 }) {
 	return {
 		create: ((context) => {
-			const optionsCount = Math.max(context.options.length, defaultOptions$4.length);
+			const optionsCount = Math.max(context.options.length, defaultOptions$5.length);
 			return create(context, Array.from({ length: optionsCount }, (_, i) => {
 				/* v8 ignore start */
-				if (isObjectNotArray(context.options[i]) && isObjectNotArray(defaultOptions$4[i])) return deepMerge(defaultOptions$4[i], context.options[i]);
-				return context.options[i] ?? defaultOptions$4[i];
+				if (isObjectNotArray(context.options[i]) && isObjectNotArray(defaultOptions$5[i])) return deepMerge(defaultOptions$5[i], context.options[i]);
+				return context.options[i] ?? defaultOptions$5[i];
 				/* v8 ignore stop */
 			}));
 		}),
-		defaultOptions: defaultOptions$4,
+		defaultOptions: defaultOptions$5,
 		meta: {
 			...meta$1,
-			defaultOptions: defaultOptions$4
+			defaultOptions: defaultOptions$5
 		}
 	};
 }
@@ -307,17 +312,17 @@ const createESLintRule = RuleCreator((ruleName) => `https://eslint-plugin-svg.nt
 * @param defaultOptions - default options
 * @returns - resolved options
 */
-function resolveOptions(options, defaultOptions$4) {
+function resolveOptions(options, defaultOptions$5) {
 	/* v8 ignore next guard by eslint */
-	return options?.[0] || defaultOptions$4;
+	return options?.[0] || defaultOptions$5;
 }
 
 //#endregion
 //#region src/rules/no-deprecated.ts
-const RULE_NAME$7 = "no-deprecated";
-const defaultOptions$3 = {};
+const RULE_NAME$12 = "no-deprecated";
+const defaultOptions$4 = {};
 var no_deprecated_default = createESLintRule({
-	name: RULE_NAME$7,
+	name: RULE_NAME$12,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -335,9 +340,9 @@ var no_deprecated_default = createESLintRule({
 		}],
 		messages: { deprecatedElement: `Element '{{name}}' is deprecated` }
 	},
-	defaultOptions: [defaultOptions$3],
+	defaultOptions: [defaultOptions$4],
 	create(context) {
-		const { allowElements = [] } = resolveOptions(context.options, defaultOptions$3);
+		const { allowElements = [] } = resolveOptions(context.options, defaultOptions$4);
 		const deprecatedElements = new Set(DEPRECATED_ELEMENTS.filter((element) => !allowElements.includes(element)));
 		return { Tag(node) {
 			if (deprecatedElements.has(node.name)) context.report({
@@ -351,9 +356,9 @@ var no_deprecated_default = createESLintRule({
 
 //#endregion
 //#region src/rules/no-doctype.ts
-const RULE_NAME$6 = "no-doctype";
+const RULE_NAME$11 = "no-doctype";
 var no_doctype_default = createESLintRule({
-	name: RULE_NAME$6,
+	name: RULE_NAME$11,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -378,10 +383,10 @@ var no_doctype_default = createESLintRule({
 
 //#endregion
 //#region src/rules/no-elements.ts
-const RULE_NAME$5 = "no-elements";
-const defaultOptions$2 = {};
+const RULE_NAME$10 = "no-elements";
+const defaultOptions$3 = {};
 var no_elements_default = createESLintRule({
-	name: RULE_NAME$5,
+	name: RULE_NAME$10,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -399,9 +404,9 @@ var no_elements_default = createESLintRule({
 		}],
 		messages: { invalid: `Element '{{name}}' is not allowed` }
 	},
-	defaultOptions: [defaultOptions$2],
+	defaultOptions: [defaultOptions$3],
 	create(context) {
-		const { elements = [] } = resolveOptions(context.options, defaultOptions$2);
+		const { elements = [] } = resolveOptions(context.options, defaultOptions$3);
 		if (!elements.length) return {};
 		return { Tag(node) {
 			if (elements.includes(node.name)) context.report({
@@ -415,10 +420,10 @@ var no_elements_default = createESLintRule({
 
 //#endregion
 //#region src/rules/no-empty-container.ts
-const RULE_NAME$4 = "no-empty-container";
-const defaultOptions$1 = {};
+const RULE_NAME$9 = "no-empty-container";
+const defaultOptions$2 = {};
 var no_empty_container_default = createESLintRule({
-	name: RULE_NAME$4,
+	name: RULE_NAME$9,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -453,9 +458,9 @@ var no_empty_container_default = createESLintRule({
 		}],
 		messages: { invalid: `Container element '{{name}}' must not be empty` }
 	},
-	defaultOptions: [defaultOptions$1],
+	defaultOptions: [defaultOptions$2],
 	create(context) {
-		const { elements = [], ignores = [], ignoreComments = true, ignoreWhitespace = true } = resolveOptions(context.options, defaultOptions$1);
+		const { elements = [], ignores = [], ignoreComments = true, ignoreWhitespace = true } = resolveOptions(context.options, defaultOptions$2);
 		const containerElements = new Set([...CONTAINER_ELEMENTS, ...elements].filter((v) => !ignores.includes(v)));
 		return { Tag(node) {
 			if (!containerElements.has(node.name)) return;
@@ -470,9 +475,9 @@ var no_empty_container_default = createESLintRule({
 
 //#endregion
 //#region src/rules/no-empty-desc.ts
-const RULE_NAME$3 = "no-empty-desc";
+const RULE_NAME$8 = "no-empty-desc";
 var no_empty_desc_default = createESLintRule({
-	name: RULE_NAME$3,
+	name: RULE_NAME$8,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -486,13 +491,36 @@ var no_empty_desc_default = createESLintRule({
 	create(context) {
 		return { Tag(node) {
 			if (node.name !== "desc") return;
-			const textNode = node.children.find((n) => n.type === "Text");
-			if (textNode) {
-				if (!textNode.value.trim()) return context.report({
-					node,
-					messageId: "invalid"
-				});
-			} else return context.report({
+			if (!node.children || node.children.length === 0 || node.children.every((child) => child.type === "Text" && !child.value.trim())) return context.report({
+				node,
+				messageId: "invalid"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-empty-groups.ts
+const RULE_NAME$7 = "no-empty-groups";
+var no_empty_groups_default = createESLintRule({
+	name: RULE_NAME$7,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "disallow empty group element",
+			recommended: true
+		},
+		schema: [],
+		messages: { invalid: `Group element 'g' must not be empty` }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { Tag(node) {
+			if (node.name !== "g") return;
+			if ((node.children ?? []).filter((child) => child.type !== "Comment").filter((child) => {
+				if (child.type !== "Text") return true;
+				return isNonEmptyString((child.value ?? "").trim());
+			}).length === 0) context.report({
 				node,
 				messageId: "invalid"
 			});
@@ -502,9 +530,9 @@ var no_empty_desc_default = createESLintRule({
 
 //#endregion
 //#region src/rules/no-empty-text.ts
-const RULE_NAME$2 = "no-empty-text";
+const RULE_NAME$6 = "no-empty-text";
 var no_empty_text_default = createESLintRule({
-	name: RULE_NAME$2,
+	name: RULE_NAME$6,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -518,13 +546,7 @@ var no_empty_text_default = createESLintRule({
 	create(context) {
 		return { Tag(node) {
 			if (node.name !== "text") return;
-			const textNode = node.children.find((n) => n.type === "Text");
-			if (textNode) {
-				if (!textNode.value.trim()) return context.report({
-					node,
-					messageId: "invalid"
-				});
-			} else return context.report({
+			if (!node.children || node.children.length === 0 || node.children.every((child) => child.type === "Text" && !child.value.trim())) return context.report({
 				node,
 				messageId: "invalid"
 			});
@@ -534,9 +556,9 @@ var no_empty_text_default = createESLintRule({
 
 //#endregion
 //#region src/rules/no-empty-title.ts
-const RULE_NAME$1 = "no-empty-title";
+const RULE_NAME$5 = "no-empty-title";
 var no_empty_title_default = createESLintRule({
-	name: RULE_NAME$1,
+	name: RULE_NAME$5,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -550,13 +572,7 @@ var no_empty_title_default = createESLintRule({
 	create(context) {
 		return { Tag(node) {
 			if (node.name !== "title") return;
-			const textNode = node.children.find((n) => n.type === "Text");
-			if (textNode) {
-				if (!textNode.value.trim()) return context.report({
-					node,
-					messageId: "invalid"
-				});
-			} else return context.report({
+			if (!node.children || node.children.length === 0 || node.children.every((child) => child.type === "Text" && !child.value.trim())) return context.report({
 				node,
 				messageId: "invalid"
 			});
@@ -564,12 +580,80 @@ var no_empty_title_default = createESLintRule({
 	}
 });
 
+//#endregion
+//#region src/rules/no-event-handlers.ts
+const RULE_NAME$4 = "no-event-handlers";
+const defaultOptions$1 = {};
+var no_event_handlers_default = createESLintRule({
+	name: RULE_NAME$4,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "disallow inline event handler attributes (e.g. onclick)",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			properties: { ignores: {
+				type: "array",
+				description: "Event handler attribute names to ignore",
+				items: { type: "string" },
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		messages: { invalid: `Inline event handler '{{name}}' is not allowed` }
+	},
+	defaultOptions: [defaultOptions$1],
+	create(context) {
+		const { ignores = [] } = resolveOptions(context.options, defaultOptions$1);
+		const ignorePatterns = ignores.map((pattern) => new RegExp(pattern));
+		const isIgnored = (name$1) => ignorePatterns.some((pattern) => pattern.test(name$1));
+		return { Attribute(node) {
+			const name$1 = node.key.value;
+			if (!name$1 || !name$1.toLowerCase().startsWith("on")) return;
+			if (isIgnored(name$1)) return;
+			context.report({
+				node: node.value ?? node.key,
+				messageId: "invalid",
+				data: { name: name$1 }
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-inline-styles.ts
+const RULE_NAME$3 = "no-inline-styles";
+var no_inline_styles_default = createESLintRule({
+	name: RULE_NAME$3,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "disallow inline style attribute usage",
+			recommended: true
+		},
+		schema: [],
+		messages: { invalid: "Inline style attributes are not allowed" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { Attribute(node) {
+			if (node.key.value !== "style") return;
+			context.report({
+				node: node.value ?? node.key,
+				messageId: "invalid"
+			});
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/no-invalid-role.ts
-const RULE_NAME = "no-invalid-role";
+const RULE_NAME$2 = "no-invalid-role";
 const defaultOptions = {};
 var no_invalid_role_default = createESLintRule({
-	name: RULE_NAME,
+	name: RULE_NAME$2,
 	meta: {
 		type: "suggestion",
 		docs: {
@@ -606,6 +690,66 @@ var no_invalid_role_default = createESLintRule({
 	}
 });
 
+//#endregion
+//#region src/rules/no-script-tags.ts
+const RULE_NAME$1 = "no-script-tags";
+var no_script_tags_default = createESLintRule({
+	name: RULE_NAME$1,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "disallow usage of script elements",
+			recommended: true
+		},
+		schema: [],
+		messages: { invalid: `Script elements are not allowed in SVG` }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { Tag(node) {
+			if (node.name !== "script") return;
+			context.report({
+				node,
+				messageId: "invalid"
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/require-viewbox.ts
+const RULE_NAME = "require-viewbox";
+var require_viewbox_default = createESLintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "require svg elements to include a non-empty viewBox attribute",
+			recommended: true
+		},
+		schema: [],
+		messages: { missing: `SVG element must include a non-empty viewBox attribute` }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { Tag(node) {
+			if (node.name !== "svg") return;
+			const viewBoxAttr = toArray(node.attributes).find((attr) => attr.key.value === "viewBox");
+			if (!viewBoxAttr) {
+				context.report({
+					node,
+					messageId: "missing"
+				});
+				return;
+			}
+			if (!isNonEmptyString((viewBoxAttr.value?.value ?? "").trim())) context.report({
+				node: viewBoxAttr.value ?? viewBoxAttr.key,
+				messageId: "missing"
+			});
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/index.ts
 const rules = {
@@ -614,9 +758,14 @@ const rules = {
 	"no-elements": no_elements_default,
 	"no-empty-container": no_empty_container_default,
 	"no-empty-desc": no_empty_desc_default,
+	"no-empty-groups": no_empty_groups_default,
 	"no-empty-text": no_empty_text_default,
 	"no-empty-title": no_empty_title_default,
-	"no-invalid-role": no_invalid_role_default
+	"no-event-handlers": no_event_handlers_default,
+	"no-inline-styles": no_inline_styles_default,
+	"no-invalid-role": no_invalid_role_default,
+	"no-script-tags": no_script_tags_default,
+	"require-viewbox": require_viewbox_default
 };
 
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-svg",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Rules for consistent, readable and valid SVG files.",
   "keywords": [
     "eslint",
@@ -34,27 +34,27 @@
     "eslint": "^9.5.0"
   },
   "dependencies": {
-    "@ntnyq/utils": "^0.10.0",
+    "@ntnyq/utils": "^0.11.0",
     "@types/json-schema": "^7.0.15",
-    "svg-eslint-parser": "^0.0.5",
+    "svg-eslint-parser": "^0.0.7",
     "uncase": "^0.2.0"
   },
   "devDependencies": {
-    "@ntnyq/eslint-config": "^5.9.0",
+    "@ntnyq/eslint-config": "^6.0.0-beta.2",
     "@ntnyq/prettier-config": "^3.0.1",
-    "@types/node": "^25.0.3",
-    "bumpp": "^10.3.2",
+    "@types/node": "^25.0.10",
+    "bumpp": "^10.4.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-eslint-plugin": "^7.2.0",
+    "eslint-plugin-eslint-plugin": "^7.3.0",
     "eslint-vitest-rule-tester": "^3.0.1",
     "husky": "^9.1.7",
     "nano-staged": "^0.9.0",
     "npm-run-all2": "^8.0.4",
-    "prettier": "^3.7.4",
+    "prettier": "^3.8.1",
     "tinyglobby": "^0.2.15",
-    "tsdown": "^0.19.0-beta.2",
+    "tsdown": "^0.20.0-beta.4",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.17"
   },
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"