@sabzidev/eslint-rules 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abolfazl Sabzmohammadi | ابوالفضل سبزمحمدی
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,164 @@
-# Temporary Holding Version
+# 🛠️ @sabzidev/eslint-rules
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A collection of custom ESLint rules for improving code quality, consistency, and maintainability.
+
+---
+
+## 👀 Overview
+
+<div align="center">
+  <img src="https://img.shields.io/npm/dm/@sabzidev/eslint-rules?style=flat-square&&color=16A34A&label=DOWNLOADS" alt="DOWNLOADS"/>
+  <img src="https://img.shields.io/npm/v/@sabzidev/eslint-rules?style=flat-square&color=16A34A&label=VERSION" alt="VERSION"/>
+  <br />
+  <img src="./docs/images/logo.webp" alt="SabziDev logo" height="300" width="70%"/>
+
+[GITHUB](https://github.com/SabziDev/eslint-rules) | [NPM](https://npmjs.com/package/@sabzidev/eslint-rules)
+</div>
+
+---
+
+## ✨ Features
+
+- Recommended configuration for ESLint Flat Config.
+- Easy integration into existing ESLint setups.
+
+---
+
+## 📦 Installation
+
+Install the package as a development dependency:
+
+```bash
+pnpm add -D @sabzidev/eslint-rules
+```
+
+---
+
+## 🚀 Usage
+
+Choose **one** of the following configuration methods.
+
+### ● Recommended Configuration
+
+Add the recommended configuration to your existing `eslint.config.js` file:
+
+```js
+import sabzidev from "@sabzidev/eslint-rules";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  // Your existing configurations
+  sabzidev.configs.recommended,
+]);
+```
+
+This enables all rules included in the recommended configuration with their predefined severity levels.
+
+### ● Custom Configuration
+
+Alternatively, register the plugin and configure each rule individually in your existing `eslint.config.js` file:
+
+```js
+import sabzidev from "@sabzidev/eslint-rules";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    plugins: {
+      "@sabzidev": sabzidev,
+    },
+    rules: {
+      "@sabzidev/merge-duplicate-id-and-classname-props": "warn",
+      "@sabzidev/merge-exports": "warn",
+      "@sabzidev/no-invalid-id-and-classname-value": "warn",
+      "@sabzidev/no-useless-empty-type": "warn",
+      "@sabzidev/no-useless-template-literal": "warn",
+      "@sabzidev/padding-before-jump-statement": "warn",
+      "@sabzidev/sort-comments": "warn",
+      "@sabzidev/sort-jsx-props": "warn",
+      "@sabzidev/sort-object-props": "warn",
+    },
+  },
+]);
+```
+
+---
+
+## ⭐ Recommended Tooling Setup
+
+For a more comprehensive linting setup, combine `@sabzidev/eslint-rules` with [`@fullstacksjs/eslint-config`](https://www.npmjs.com/package/@fullstacksjs/eslint-config), [`eslint-plugin-sonarjs`](https://www.npmjs.com/package/eslint-plugin-sonarjs), and [`eslint-plugin-unicorn`](https://www.npmjs.com/package/eslint-plugin-unicorn).
+
+This combination brings together code-quality rules, bug detection, maintainability checks, and custom linting rules.
+
+```js
+import { defineConfig } from "@fullstacksjs/eslint-config";
+import sabzidev from "@sabzidev/eslint-rules";
+import sonarjs from "eslint-plugin-sonarjs";
+import unicorn from "eslint-plugin-unicorn";
+
+const baseRules = {
+  "func-style": ["warn", "expression"],
+  quotes: [
+    "error",
+    "double",
+    { avoidEscape: true, allowTemplateLiterals: false },
+  ],
+  eqeqeq: ["error", "always"],
+  "no-console": "warn",
+};
+const plugins = [
+  sabzidev.configs.recommended,
+  sonarjs.configs.recommended,
+  unicorn.configs.recommended,
+];
+const pluginsRules = {
+  "unicorn/filename-case": "off",
+  "unicorn/prefer-global-this": "off",
+  "unicorn/name-replacements": "off",
+  "unicorn/no-array-sort": "off",
+  "unicorn/no-null": "off",
+  "unicorn/default-export-style": "off",
+
+  "jsx-a11y/click-events-have-key-events": "off",
+  "jsx-a11y/no-noninteractive-element-interactions": "off",
+};
+
+const config = defineConfig(
+  {
+    tailwind: { entryPoint: "./src/input.css" },
+    rules: baseRules,
+  },
+
+  plugins,
+  { rules: pluginsRules },
+);
+
+export default config;
+```
+
+**Note:** Customize the rules to match your project's requirements and verify compatibility with your installed plugin versions.
+
+---
+
+## 📋 Available Rules
+
+| Rule                                     | Description                                  |
+| :--------------------------------------- | :------------------------------------------- |
+| `merge-duplicate-id-and-classname-props` | Merges duplicate `id` and `className` props. |
+| `merge-exports`                          | Merges or organizes export declarations.     |
+| `no-invalid-id-and-classname-value`      | Detects invalid `id` and `className` values. |
+| `no-useless-empty-type`                  | Detects unnecessary empty types.             |
+| `no-useless-template-literal`            | Detects unnecessary template literals.       |
+| `padding-before-jump-statement`          | Enforces padding before jump statements.     |
+| `sort-comments`                          | Sorts comments.                              |
+| `sort-jsx-props`                         | Sorts JSX props.                             |
+| `sort-object-props`                      | Sorts object properties.                     |
+
+---
+
+## 👨‍💻 Developer
+
+Developed by **Abolfazl Sabzmohammadi**.
+
+- GitHub: [SabziDev](https://github.com/SabziDev)
+- Website: [Sabzi.Dev](https://Sabzi.Dev)

package/dist/index.js

@@ -0,0 +1,553 @@
+var e = {
+	name: "@sabzidev/eslint-rules",
+	description: "A collection of ESLint rules for better code quality, consistency, and maintainability.",
+	repository: {
+		type: "git",
+		url: "https://github.com/SabziDev/eslint-rules"
+	},
+	license: "MIT",
+	keywords: [
+		"SabziDev",
+		"eslint",
+		"eslint-plugin",
+		"eslint-rules",
+		"code-quality",
+		"code-style",
+		"linting",
+		"developer-tools"
+	],
+	author: "Abolfazl Sabzmohammadi <SabziDev@gmail.com> (https://Sabzi.Dev)",
+	version: "1.0.0",
+	type: "module",
+	main: "./dist/index.js",
+	exports: "./dist/index.js",
+	files: [
+		"dist",
+		"docs",
+		"README.md",
+		"LICENSE"
+	],
+	publishConfig: { access: "public" },
+	scripts: { build: "vite build" },
+	devDependencies: {
+		eslint: "^10.12.0",
+		prettier: "^3.9.9",
+		"@fullstacksjs/eslint-config": "^15.3.0",
+		"eslint-plugin-sonarjs": "^4.2.2",
+		"eslint-plugin-unicorn": "^77.0.0",
+		vite: "^8.3.0"
+	}
+}, t = {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		messages: { merge: "Duplicate '{{prop}}' props should be merged into one" }
+	},
+	create(e) {
+		let t = (e) => {
+			let { value: t } = e;
+			return t ? t.type === "Literal" ? t.value : t.type === "JSXExpressionContainer" && t.expression.type === "Literal" ? t.expression.value : null : null;
+		};
+		return { JSXOpeningElement(n) {
+			for (let r of ["className", "id"]) {
+				let i = n.attributes.filter((e) => e.type === "JSXAttribute" && e.name?.name === r);
+				if (i.length < 2) continue;
+				let a = [];
+				for (let e of i) {
+					let n = t(e);
+					if (typeof n != "string") return;
+					a.push(n);
+				}
+				e.report({
+					data: { prop: r },
+					node: i[1],
+					messageId: "merge",
+					fix(e) {
+						let t = [...new Set(a)].join(" ").trim(), n = [e.replaceText(i[0], `${r}="${t}"`)];
+						for (let t = 1; t < i.length; t++) n.push(e.remove(i[t]));
+						return n;
+					}
+				});
+			}
+		} };
+	}
+}, n = {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		messages: { mergeExports: "Combine and move exports into a single export block at the end of the file" }
+	},
+	create(e) {
+		let { sourceCode: t } = e, n = (e) => e?.type === "ExportNamedDeclaration" && !e.source && !e.declaration && e.specifiers?.length > 0, r = (e) => e?.type === "ExportDefaultDeclaration", i = (e) => n(e) || r(e), a = (e) => e.exported.name ?? e.exported.value;
+		return { Program(o) {
+			let { body: s } = o, c = s.filter(i);
+			if (c.length === 0) return;
+			let l = c.filter(n), u = c.find(r), d = l.flatMap(({ specifiers: e }) => e).map((e) => ({
+				name: a(e),
+				text: t.getText(e)
+			})).sort((e, t) => e.name.localeCompare(t.name)), f = [d.length > 0 ? `export { ${d.map(({ text: e }) => e).join(", ")} };` : "", u ? t.getText(u) : ""].filter(Boolean).join("\n"), p = c.map(({ range: e }) => e).sort((e, t) => t[0] - e[0]), m = t.text;
+			for (let [e, t] of p) m = m.slice(0, e) + m.slice(t);
+			let h = `${m.replace(/\s+$/, "")}\n\n${f}\n`;
+			t.text !== h && e.report({
+				node: c[0],
+				messageId: "mergeExports",
+				fix(e) {
+					return e.replaceText(o, h);
+				}
+			});
+		} };
+	}
+}, r = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		messages: {
+			invalid: "{{attribute}} cannot be {{value}}!",
+			singleItemArray: "{{attribute}} should not use an array with only one item!"
+		}
+	},
+	create(e) {
+		let t = /* @__PURE__ */ new Set(["className", "id"]), n = e.sourceCode || e.getSourceCode(), r = (e) => {
+			if (e.length === 0) return {
+				invalidValue: "empty",
+				index: -2
+			};
+			for (let [t, n] of e.entries()) if (n.type === "Literal") {
+				if (n.value === "") return {
+					invalidValue: "empty",
+					index: t
+				};
+				if ([
+					!1,
+					null,
+					!0
+				].includes(n.value)) return {
+					invalidValue: String(n.value),
+					index: t
+				};
+			} else if (n.type === "Identifier" && n.name === "undefined") return {
+				invalidValue: "undefined",
+				index: t
+			};
+			return null;
+		};
+		return { JSXAttribute(i) {
+			let a = i.name.name;
+			if (!t.has(a) || !i.value) return;
+			let o, s = -1, c = !1;
+			if (i.value.type === "Literal" && i.value.value === "") o = "empty";
+			else if (i.value.type === "JSXExpressionContainer") {
+				let { expression: t } = i.value;
+				if (t.type === "Literal" && [
+					!1,
+					null,
+					!0
+				].includes(t.value)) o = String(t.value);
+				else if (t.type === "Identifier" && t.name === "undefined") o = "undefined";
+				else if (t.type === "ArrayExpression") {
+					c = !0;
+					let e = r(t.elements);
+					e && ({invalidValue: o, index: s} = e);
+				} else if (t.type === "ObjectExpression") t.properties.length === 0 && (o = "empty");
+				else if (t.type === "CallExpression" && t.callee.name === "clsx" && t.arguments.length === 1) {
+					let n = t.arguments[0];
+					if (n.type === "ArrayExpression") {
+						c = !0;
+						let l = r(n.elements);
+						if (l && ({invalidValue: o, index: s} = l), c && t.type === "CallExpression" && t.callee.name === "clsx") {
+							let n = t.arguments[0];
+							if (n?.type === "ArrayExpression" && n.elements.length === 1 && n.elements[0]?.type === "Literal") {
+								e.report({
+									data: {
+										value: "single-item-array",
+										attribute: a
+									},
+									node: i,
+									messageId: "singleItemArray",
+									fix: (e) => e.replaceText(i.value, `{${n.elements[0].raw}}`)
+								});
+								return;
+							}
+						}
+					} else n.type === "Literal" && n.value === "" ? o = "empty" : n.type === "Literal" && [
+						!1,
+						null,
+						!0
+					].includes(n.value) ? o = String(n.value) : n.type === "Identifier" && n.name === "undefined" ? o = "undefined" : n.type === "ObjectExpression" && n.properties.length === 0 && (o = "empty");
+				}
+			}
+			o && e.report({
+				data: {
+					value: o,
+					attribute: a
+				},
+				node: i,
+				messageId: o === "single-item-array" ? "singleItemArray" : "invalid",
+				fix: (e) => {
+					if (s === -2 || s === -1 || !c) return e.remove(i);
+					let { elements: t } = i.value.expression.arguments ? i.value.expression.arguments[0] : i.value.expression;
+					if (t.length === 1) return e.remove(i);
+					let r = t[s], a = t[s + 1], o = t[s - 1], l;
+					l = a ? [r.range[0], a.range[0]] : o ? [o.range[1], r.range[1]] : r.range;
+					let u = n.getText().slice(0, l[0]) + n.getText().slice(l[1]);
+					return e.replaceTextRange([0, n.getText().length], u);
+				}
+			});
+		} };
+	}
+}, i = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		messages: {
+			emptyType: "Empty type alias is not allowed.",
+			emptyInterface: "Empty interface is not allowed."
+		},
+		schema: []
+	},
+	create(e) {
+		return {
+			TSTypeAliasDeclaration(t) {
+				t.typeAnnotation.type === "TSTypeLiteral" && t.typeAnnotation.members.length === 0 && e.report({
+					node: t,
+					messageId: "emptyType",
+					fix(e) {
+						return e.remove(t);
+					}
+				});
+			},
+			TSInterfaceDeclaration(t) {
+				t.body.body.length === 0 && e.report({
+					node: t,
+					messageId: "emptyInterface",
+					fix(e) {
+						return e.remove(t);
+					}
+				});
+			}
+		};
+	}
+}, a = {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		messages: { remove: "This template literal has a single expression and can be replaced with the expression itself" }
+	},
+	create(e) {
+		let t = e.sourceCode || e.getSourceCode();
+		return { TemplateLiteral(n) {
+			if (n.expressions.length !== 1) return;
+			let r = n.quasis[0].value.raw === "", i = n.quasis[1].value.raw === "";
+			if (!(r && i)) return;
+			let a = n.expressions[0], o = t.getText(a);
+			e.report({
+				node: n,
+				messageId: "remove",
+				fix: (e) => e.replaceText(n, o)
+			});
+		} };
+	}
+}, o = [
+	"ReturnStatement",
+	"BreakStatement",
+	"ContinueStatement",
+	"ThrowStatement"
+], s = {
+	meta: {
+		type: "layout",
+		fixable: "code",
+		messages: { missingBlankLine: "Expected a blank line before statement" },
+		schema: []
+	},
+	create(e) {
+		let { sourceCode: t = e.getSourceCode() } = e, n = new Set(o), r = (e) => n.has(e), i = (e, t) => {
+			let n = t.indexOf(e);
+			if (n <= 0) return !1;
+			let { type: i } = t[n - 1];
+			return !r(i);
+		}, a = (e) => {
+			let { parent: t } = e;
+			if (t?.type === "BlockStatement") {
+				let { body: n } = t;
+				if (n.length === 1 && n[0] === e || n.length === 1 && r(n[0].type)) return !0;
+			}
+			if (t?.type === "ArrowFunctionExpression" && t.body === e) {
+				let { body: n } = t;
+				return r(n.type) && n === e;
+			}
+			return !1;
+		}, s = (e) => {
+			let n = t.getTokenBefore(e, { includeComments: !0 });
+			if (!n) return !0;
+			let { end: r } = n.loc, { start: i } = e.loc;
+			return i.line - r.line > 1;
+		}, c = (e) => {
+			let n = t.getTokenBefore(e, { includeComments: !0 });
+			for (; n && (n.type === "Line" || n.type === "Block");) n = t.getTokenBefore(n, { includeComments: !0 });
+			return n;
+		}, l = (e) => {
+			let t = c(e);
+			if (!t) return !1;
+			let { end: n } = t.loc, { start: r } = e.loc;
+			return r.line - n.line === 1;
+		}, u = (e) => {
+			let { parent: t } = e;
+			for (; t;) {
+				let { type: e } = t;
+				if (e === "BlockStatement" || e === "Program") return { parentBody: t.body };
+				t = t.parent;
+			}
+			return { parentBody: null };
+		}, d = (n) => {
+			if (a(n)) return;
+			let { parentBody: o } = u(n);
+			if (!o || !i(n, o)) return;
+			let c = t.getTokenBefore(n, { includeComments: !0 });
+			if (c && (c.type === "Line" || c.type === "Block")) {
+				l(c) && e.report({
+					node: n,
+					messageId: "missingBlankLine",
+					fix: (e) => e.insertTextBefore(c, "\n")
+				});
+				return;
+			}
+			if (s(n)) return;
+			let { type: d } = o[o.indexOf(n) - 1] || {};
+			r(d) || e.report({
+				node: n,
+				messageId: "missingBlankLine",
+				fix: (e) => e.insertTextBefore(n, "\n")
+			});
+		};
+		return Object.fromEntries(o.map((e) => [e, d]));
+	}
+}, c = {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		messages: { reorganize: "Comments should be ordered!" }
+	},
+	create(e) {
+		let { sourceCode: t } = e, { text: n } = t, r = t.getAllComments(), i = [];
+		for (let e of r) {
+			let t = e.value.trim();
+			e.type === "Block" && /^eslint-disable\s+/.test(t) && i.push({
+				text: `/* ${t} */`,
+				line: e.loc.start.line,
+				range: e.range
+			});
+		}
+		return i.length === 0 ? {} : { Program(t) {
+			i.sort((e, t) => e.line - t.line);
+			let r = "";
+			for (let e = 0; e < i.length; e++) r += i[e].text, e < i.length - 1 && (r += "\n");
+			r += "\n\n";
+			let a = n;
+			for (let e = i.length - 1; e >= 0; e--) {
+				let t = i[e];
+				a = a.slice(0, t.range[0]) + a.slice(t.range[1]);
+			}
+			for (; a.startsWith("\n");) a = a.slice(1);
+			let o = r + a;
+			n !== o && e.report({
+				node: t,
+				messageId: "reorganize",
+				fix: (e) => e.replaceTextRange([0, n.length], o)
+			});
+		} };
+	}
+}, l = /* @__PURE__ */ "children.key.id.ref.data.title.desc.htmlFor.type.inputMode.name.value.placeholder.autoComplete.min.max.minLength.maxLength.src.alt.loading.poster.preload.controls.href.target.rel.to.replace.viewTransition".split("."), u = [
+	"onClick",
+	"onChange",
+	"onKeyUp"
+], d = {
+	"merge-duplicate-id-and-classname-props": t,
+	"merge-exports": n,
+	"no-invalid-id-and-classname-value": r,
+	"no-useless-empty-type": i,
+	"no-useless-template-literal": a,
+	"padding-before-jump-statement": s,
+	"sort-comments": c,
+	"sort-jsx-props": {
+		meta: {
+			type: "suggestion",
+			fixable: "code",
+			messages: { wrongOrder: "Props should be ordered!" }
+		},
+		create(e) {
+			let { sourceCode: t } = e, n = new Set(l), r = (e) => /^on[A-Z]/.test(e), i = (e) => {
+				let t = u.indexOf(e);
+				return t === -1 ? 999 : t;
+			};
+			return { JSXOpeningElement(a) {
+				let o = a.attributes, s = o.filter((e) => e.type === "JSXSpreadAttribute"), c = o.filter((e) => e.type === "JSXAttribute");
+				if (c.length === 0 && s.length === 0) return;
+				let u = l.flatMap((e) => c.filter((t) => t.name.name === e)), d = c.filter((e) => r(e.name.name)).sort((e, t) => {
+					let n = i(e.name.name), r = i(t.name.name);
+					return n === 999 && r === 999 ? 0 : n - r;
+				}), f = c.filter((e) => ["className", "style"].includes(e.name.name)).sort((e, t) => e.name.name === "className" && t.name.name === "style" ? -1 : +(e.name.name === "style" && t.name.name === "className")), p = c.filter((e) => {
+					let { name: t } = e.name;
+					return !n.has(t) && !r(t) && !["className", "style"].includes(t);
+				}), m = [
+					...u,
+					...p,
+					...d,
+					...f,
+					...s
+				], h = !1, g = [];
+				for (let e of o) (e.type === "JSXAttribute" || e.type === "JSXSpreadAttribute") && g.push(e);
+				if (g.length === m.length) {
+					for (let [e, t] of g.entries()) if (t !== m[e]) {
+						h = !0;
+						break;
+					}
+				} else h = !0;
+				if (!h) return;
+				let _ = `<${t.getText(a.name)} ${m.map((e) => t.getText(e)).join(" ")}${a.selfClosing ? " />" : ">"}`;
+				e.report({
+					node: a,
+					messageId: "wrongOrder",
+					fix: (e) => e.replaceTextRange([a.range[0], a.range[1]], _)
+				});
+			} };
+		}
+	},
+	"sort-object-props": {
+		meta: {
+			type: "suggestion",
+			fixable: "code",
+			messages: {
+				wrongOrder: "Object properties should be ordered!",
+				wrongDestructure: "Destructured properties should be ordered!",
+				wrongParams: "Function parameters should be ordered!",
+				wrongTypeProperties: "Type properties should be ordered!"
+			}
+		},
+		create(e) {
+			let { sourceCode: t } = e, n = new Set(l), r = (e) => /^on[A-Z]/.test(e), i = (e) => {
+				let t = u.indexOf(e);
+				return t === -1 ? 999 : t;
+			}, a = (e) => e ? e.type === "Property" || e.type === "TSPropertySignature" || e.type === "TSMethodSignature" || e.type === "TSCallSignatureDeclaration" || e.type === "TSConstructSignatureDeclaration" ? e.key?.name || e.key?.value || "" : e.type === "Identifier" ? e.name : "" : "", o = (e) => e.type === "SpreadElement" || e.type === "RestElement" || e.type === "ExperimentalRestProperty", s = (e) => e.type === "TSPropertySignature" || e.type === "TSMethodSignature" || e.type === "TSCallSignatureDeclaration" || e.type === "TSConstructSignatureDeclaration" || e.type === "TSIndexSignature", c = (e) => {
+				if (e.length === 0) return e;
+				let t = l.flatMap((t) => e.filter((e) => a(e) === t)), o = e.filter((e) => {
+					let t = a(e);
+					return !n.has(t) && !r(t) && !["className", "style"].includes(t);
+				}), s = e.filter((e) => {
+					let t = a(e);
+					return r(t);
+				}).sort((e, t) => {
+					let n = i(a(e)), r = i(a(t));
+					return n === 999 && r === 999 ? 0 : n - r;
+				}), c = e.filter((e) => {
+					let t = a(e);
+					return ["className", "style"].includes(t);
+				}).sort((e, t) => {
+					let n = a(e), r = a(t);
+					return n === "className" && r === "style" ? -1 : +(n === "style" && r === "className");
+				});
+				return [
+					...t,
+					...o,
+					...s,
+					...c
+				];
+			}, d = (e) => {
+				let t = [], n = [];
+				for (let r of e) if (o(r)) {
+					if (n.length > 0) {
+						let e = c(n);
+						t.push(...e), n = [];
+					}
+					t.push(r);
+				} else n.push(r);
+				if (n.length > 0) {
+					let e = c(n);
+					t.push(...e);
+				}
+				return t;
+			}, f = (e) => {
+				if (e.length <= 1) return e;
+				let t = e.filter((e) => !o(e) && s(e)), n = e.filter((e) => !t.includes(e));
+				return [...c(t), ...n];
+			}, p = (e, t) => {
+				if (e.length !== t.length) return !0;
+				for (let [n, r] of e.entries()) if (r !== t[n]) return !0;
+				return !1;
+			}, m = (e) => `{ ${e.map((e) => t.getText(e)).join(", ")} }`, h = (e) => e.map((e) => t.getText(e)).join("\n"), g = (n, r) => {
+				let { properties: i } = n;
+				if (!i || i.length <= 1) return;
+				let a = d(i);
+				if (!p(i, a)) return;
+				let o = i[0], s = i.at(-1), c = o.range[0], l = s.range[1];
+				e.report({
+					node: n,
+					messageId: r,
+					fix(e) {
+						let n = a.map((e) => t.getText(e)).join(", ");
+						return e.replaceTextRange([c, l], n);
+					}
+				});
+			}, _ = (e) => {
+				let { params: t } = e;
+				if (t && t.length !== 0) for (let e of t) e.type === "ObjectPattern" && g(e, "wrongParams");
+			}, v = (t) => {
+				let n = t.body ?? t.members;
+				if (!n || n.length <= 1) return;
+				let r = f(n);
+				if (!p(n, r)) return;
+				let i = n[0], a = n.at(-1), o = i.range[0], s = a.range[1];
+				e.report({
+					node: t,
+					messageId: "wrongTypeProperties",
+					fix(e) {
+						let t = h(r);
+						return e.replaceTextRange([o, s], t);
+					}
+				});
+			};
+			return {
+				ObjectExpression(t) {
+					let { properties: n } = t;
+					if (n.length <= 1) return;
+					let r = d(n);
+					p(n, r) && e.report({
+						node: t,
+						messageId: "wrongOrder",
+						fix(e) {
+							let n = m(r);
+							return e.replaceText(t, n);
+						}
+					});
+				},
+				ObjectPattern(e) {
+					g(e, "wrongDestructure");
+				},
+				TSTypeLiteral(e) {
+					v(e);
+				},
+				TSInterfaceBody(e) {
+					v(e);
+				},
+				TSTypeAliasDeclaration(e) {
+					e.typeAnnotation?.type === "TSTypeLiteral" && v(e.typeAnnotation);
+				},
+				FunctionDeclaration: _,
+				FunctionExpression: _,
+				ArrowFunctionExpression: _
+			};
+		}
+	}
+}, f = {
+	meta: {
+		name: e.name,
+		version: e.version
+	},
+	rules: d,
+	configs: {}
+};
+f.configs.recommended = {
+	plugins: { "@sabzidev": f },
+	rules: Object.fromEntries(Object.keys(d).map((e) => [`@sabzidev/${e}`, "warn"]))
+};
+//#endregion
+export { f as default };

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@sabzidev/eslint-rules",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "A collection of ESLint rules for better code quality, consistency, and maintainability.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SabziDev/eslint-rules"
+  },
+  "license": "MIT",
+  "keywords": [
+    "SabziDev",
+    "eslint",
+    "eslint-plugin",
+    "eslint-rules",
+    "code-quality",
+    "code-style",
+    "linting",
+    "developer-tools"
+  ],
+  "author": "Abolfazl Sabzmohammadi <SabziDev@gmail.com> (https://Sabzi.Dev)",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": "./dist/index.js",
+  "files": [
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "eslint": "^10.12.0",
+    "prettier": "^3.9.9",
+    "@fullstacksjs/eslint-config": "^15.3.0",
+    "eslint-plugin-sonarjs": "^4.2.2",
+    "eslint-plugin-unicorn": "^77.0.0",
+    "vite": "^8.3.0"
+  },
+  "scripts": {
+    "build": "vite build"
+  }
 }