@utilfirst/eslint-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ayan Yenbekbay
+
+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

@@ -0,0 +1,56 @@
+# @utilfirst/eslint-plugin
+
+Shared ESLint rules for utilfirst projects. Flat config only, ESLint v9 / v10.
+
+## Install
+
+```sh
+pnpm add -D @utilfirst/eslint-plugin
+```
+
+## Use
+
+```js
+// eslint.config.mjs
+import utilfirst from "@utilfirst/eslint-plugin";
+
+export default [
+  utilfirst.configs.recommended,
+  // ...your other configs
+];
+```
+
+Or wire rules individually:
+
+```js
+import utilfirst from "@utilfirst/eslint-plugin";
+
+export default [
+  {
+    plugins: { utilfirst },
+    rules: {
+      "utilfirst/consistent-blank-lines": "error",
+    },
+  },
+];
+```
+
+## Rules
+
+| Rule                                                               | Description                                                                          | Fixable |
+| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ------- |
+| [`consistent-blank-lines`](./docs/rules/consistent-blank-lines.md) | Insert blank lines between statement-list and JSXChild items that start new thoughts | yes     |
+
+## Develop
+
+```sh
+pnpm install
+pnpm run setup-hooks # one-time: wire pre-commit via simple-git-hooks
+pnpm test            # vitest + @typescript-eslint/rule-tester
+pnpm run build       # tsdown → dist/
+pnpm run lint        # eslint + prettier + publint + tsc
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { TSESLint } from "@typescript-eslint/utils";
+
+//#region src/index.d.ts
+declare const plugin: {
+  meta: {
+    readonly name: "@utilfirst/eslint-plugin";
+    readonly version: "0.1.0";
+  };
+  rules: {
+    "consistent-blank-lines": TSESLint.RuleModule<"extra" | "missing", [], unknown, TSESLint.RuleListener>;
+  };
+  configs: {
+    recommended: TSESLint.FlatConfig.Config;
+  };
+};
+//#endregion
+export { plugin as default };

package/dist/index.js

@@ -0,0 +1,466 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region src/rules/consistent-blank-lines.ts
+const SKIP_KEYS = new Set([
+	"parent",
+	"loc",
+	"range",
+	"start",
+	"end"
+]);
+const FN_DECL_TYPES = new Set([
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.FunctionExpression,
+	AST_NODE_TYPES.ArrowFunctionExpression
+]);
+const IMPORT_SPECIFIER_TYPES = new Set([
+	AST_NODE_TYPES.ImportSpecifier,
+	AST_NODE_TYPES.ImportDefaultSpecifier,
+	AST_NODE_TYPES.ImportNamespaceSpecifier
+]);
+const OPAQUE_BODY_TYPES = new Set([
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.ClassDeclaration,
+	AST_NODE_TYPES.ClassExpression
+]);
+const FLOW_PREV_TYPES = new Set([AST_NODE_TYPES.ExpressionStatement, AST_NODE_TYPES.IfStatement]);
+const FLOW_NEXT_TYPES = new Set([
+	AST_NODE_TYPES.ExpressionStatement,
+	AST_NODE_TYPES.IfStatement,
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ThrowStatement,
+	AST_NODE_TYPES.BreakStatement,
+	AST_NODE_TYPES.ContinueStatement
+]);
+const HEAVY_NEXT_TYPES = new Set([
+	AST_NODE_TYPES.VariableDeclaration,
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.ClassDeclaration,
+	AST_NODE_TYPES.TSInterfaceDeclaration,
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ThrowStatement
+]);
+const TERMINATING_STATEMENT_TYPES = new Set([
+	AST_NODE_TYPES.ReturnStatement,
+	AST_NODE_TYPES.ThrowStatement,
+	AST_NODE_TYPES.BreakStatement,
+	AST_NODE_TYPES.ContinueStatement
+]);
+function parentOf(node) {
+	return node.parent;
+}
+const consistentBlankLines = {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "Insert blank lines between statement-list and JSXChild items that start a new thought.",
+			url: "https://github.com/utilfirst/utilfirst-eslint-plugin/blob/main/docs/rules/consistent-blank-lines.md"
+		},
+		fixable: "whitespace",
+		schema: [],
+		messages: {
+			extra: "Unexpected blank line between statements that continue the same paragraph.",
+			missing: "Expected a blank line between statements that start new paragraphs."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		const sourceCode = context.sourceCode;
+		function checkBlock(statements) {
+			for (let i = 0; i < statements.length - 1; i++) {
+				const prev = statements[i];
+				const next = statements[i + 1];
+				if (prev && next) checkPair(prev, next, sourceCode.getCommentsBefore(next)[0] ?? next, () => sameParagraph(prev, next, sourceCode), () => isImportPair(prev, next) || isReExport(prev) && isReExport(next));
+			}
+		}
+		function checkJsxChildren(children) {
+			const siblings = [];
+			let pendingLeading = [];
+			for (const child of children) {
+				if (child.type === AST_NODE_TYPES.JSXText && child.value.trim() === "") continue;
+				if (isCommentOnlyContainer(child)) {
+					pendingLeading.push(child);
+					continue;
+				}
+				siblings.push({
+					leading: pendingLeading,
+					node: child
+				});
+				pendingLeading = [];
+			}
+			for (let i = 0; i < siblings.length - 1; i++) {
+				const prevSibling = siblings[i];
+				const nextSibling = siblings[i + 1];
+				if (prevSibling && nextSibling) {
+					const { node: prev } = prevSibling;
+					const { leading, node: next } = nextSibling;
+					checkPair(prev, next, leading[0] ?? next, () => sameJsxParagraph(prev, next, leading), () => false);
+				}
+			}
+		}
+		function checkPair(prev, next, effectiveStart, isSameParagraph, shouldPreserveExtra) {
+			const prevEndLine = prev.loc.end.line;
+			const nextStartLine = effectiveStart.loc.start.line;
+			if (nextStartLine - prevEndLine < 1) return;
+			const isPaddingRequired = !isSameParagraph();
+			const paddingCount = nextStartLine - prevEndLine - 1;
+			const targetPadding = isPaddingRequired ? 1 : 0;
+			if (paddingCount === targetPadding) return;
+			if (paddingCount > targetPadding && shouldPreserveExtra()) return;
+			context.report({
+				node: next,
+				messageId: paddingCount < targetPadding ? "missing" : "extra",
+				fix(fixer) {
+					const start = sourceCode.getIndexFromLoc({
+						line: prevEndLine + 1,
+						column: 0
+					});
+					const end = sourceCode.getIndexFromLoc({
+						line: nextStartLine,
+						column: 0
+					});
+					return fixer.replaceTextRange([start, end], "\n".repeat(targetPadding));
+				}
+			});
+		}
+		return {
+			Program(node) {
+				checkBlock(node.body);
+			},
+			BlockStatement(node) {
+				checkBlock(node.body);
+			},
+			SwitchCase(node) {
+				checkBlock(node.consequent);
+			},
+			StaticBlock(node) {
+				checkBlock(node.body);
+			},
+			JSXElement(node) {
+				checkJsxChildren(node.children);
+			},
+			JSXFragment(node) {
+				checkJsxChildren(node.children);
+			}
+		};
+	}
+};
+function sameParagraph(prev, next, sourceCode) {
+	if (hasMultiLineLeadingComment(next, sourceCode)) return false;
+	const prevHook = isHookStatement(prev);
+	const nextHook = isHookStatement(next);
+	if (prevHook || nextHook) return prevHook && nextHook && isMatchingVarDeclPair(prev, next);
+	return sharesNameFlow(prev, next, sourceCode) || sameShape(prev, next);
+}
+function isHookStatement(stmt) {
+	if (stmt.type === AST_NODE_TYPES.VariableDeclaration && stmt.declarations.length === 1) return isHookCall(stmt.declarations[0].init);
+	if (stmt.type === AST_NODE_TYPES.ExpressionStatement) return isHookCall(stmt.expression);
+	return false;
+}
+function sharesNameFlow(prev, next, sourceCode) {
+	if (isMultiLine(prev)) return false;
+	const nextType = unwrapExport(next).type;
+	if (isMultiLine(next) && HEAVY_NEXT_TYPES.has(nextType)) return false;
+	if (nextType === AST_NODE_TYPES.TSTypeAliasDeclaration) return false;
+	const introduced = collectIntroducedOrAssignedNames(prev);
+	if (introduced.size === 0) return false;
+	const referenced = collectReferencedNames(next, sourceCode);
+	for (const name of introduced) if (referenced.has(name)) return true;
+	return false;
+}
+function isHookCall(node) {
+	return node?.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.Identifier && /^use[A-Z]/.test(node.callee.name);
+}
+function sameShape(prev, next) {
+	if (isImportPair(prev, next)) return true;
+	if (isReExport(prev) && isReExport(next)) return true;
+	if (isMatchingVarDeclPair(prev, next)) return true;
+	if (isMatchingTypeAliasPair(prev, next)) return true;
+	if (FLOW_PREV_TYPES.has(prev.type) && FLOW_NEXT_TYPES.has(next.type)) {
+		if (HEAVY_NEXT_TYPES.has(next.type) && isMultiLine(next)) return false;
+		if (prev.type === AST_NODE_TYPES.IfStatement) {
+			if (next.type !== AST_NODE_TYPES.IfStatement) return false;
+			if (isGuardIf(prev) && !isGuardIf(next)) return false;
+		} else if (next.type === AST_NODE_TYPES.IfStatement && isGuardIf(next)) return false;
+		return true;
+	}
+	return false;
+}
+function isImportPair(prev, next) {
+	return prev.type === AST_NODE_TYPES.ImportDeclaration && next.type === AST_NODE_TYPES.ImportDeclaration;
+}
+function isReExport(stmt) {
+	return stmt.type === AST_NODE_TYPES.ExportNamedDeclaration && stmt.source !== null || stmt.type === AST_NODE_TYPES.ExportAllDeclaration;
+}
+function isMatchingVarDeclPair(prev, next) {
+	const p = unwrapExport(prev);
+	const n = unwrapExport(next);
+	if (p.type !== AST_NODE_TYPES.VariableDeclaration || n.type !== AST_NODE_TYPES.VariableDeclaration) return false;
+	if (!isConstOrLet(p) || !isConstOrLet(n)) return false;
+	if (isMultiLine(prev) || isMultiLine(next)) return false;
+	if (p.declarations.length !== 1 || n.declarations.length !== 1) return false;
+	if (!initsMatchByShape(p.declarations[0].init, n.declarations[0].init)) return false;
+	return prev.type === AST_NODE_TYPES.ExportNamedDeclaration === (next.type === AST_NODE_TYPES.ExportNamedDeclaration);
+}
+function isMatchingTypeAliasPair(prev, next) {
+	const p = unwrapExport(prev);
+	const n = unwrapExport(next);
+	if (p.type !== AST_NODE_TYPES.TSTypeAliasDeclaration || n.type !== AST_NODE_TYPES.TSTypeAliasDeclaration) return false;
+	if (isMultiLine(prev) || isMultiLine(next)) return false;
+	return prev.type === AST_NODE_TYPES.ExportNamedDeclaration === (next.type === AST_NODE_TYPES.ExportNamedDeclaration);
+}
+function unwrapExport(stmt) {
+	if (stmt.type === AST_NODE_TYPES.ExportNamedDeclaration && stmt.declaration) return stmt.declaration;
+	return stmt;
+}
+function isConstOrLet(decl) {
+	return decl.kind === "const" || decl.kind === "let";
+}
+function initsMatchByShape(prevInit, nextInit) {
+	const prevCall = asCall(prevInit);
+	const nextCall = asCall(nextInit);
+	if (prevCall && nextCall) {
+		if (calleesEqual(prevCall.callee, nextCall.callee)) return true;
+		return prevCall.arguments.length === 0 && nextCall.arguments.length === 0;
+	}
+	if (prevCall || nextCall) return false;
+	return true;
+}
+function asCall(expr) {
+	if (!expr) return null;
+	if (expr.type === AST_NODE_TYPES.CallExpression) return expr;
+	return null;
+}
+function calleesEqual(a, b) {
+	if (!a || a.type !== b?.type) return false;
+	if (a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier) return a.name === b.name;
+	if (a.type === AST_NODE_TYPES.ThisExpression) return true;
+	if (a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression) {
+		if (a.computed !== b.computed) return false;
+		if (!calleesEqual(a.object, b.object)) return false;
+		if (!a.computed && a.property.type === AST_NODE_TYPES.Identifier && b.property.type === AST_NODE_TYPES.Identifier) return a.property.name === b.property.name;
+		return false;
+	}
+	if (a.type === AST_NODE_TYPES.CallExpression && b.type === AST_NODE_TYPES.CallExpression) return calleesEqual(a.callee, b.callee);
+	return false;
+}
+function isGuardIf(stmt) {
+	return stmt.type === AST_NODE_TYPES.IfStatement && blockAlwaysTerminates(stmt.consequent);
+}
+function blockAlwaysTerminates(node) {
+	if (!node) return false;
+	if (TERMINATING_STATEMENT_TYPES.has(node.type)) return true;
+	if (node.type === AST_NODE_TYPES.BlockStatement) {
+		const last = node.body[node.body.length - 1];
+		return last ? blockAlwaysTerminates(last) : false;
+	}
+	if (node.type === AST_NODE_TYPES.IfStatement) return Boolean(node.alternate) && blockAlwaysTerminates(node.consequent) && blockAlwaysTerminates(node.alternate);
+	if (node.type === AST_NODE_TYPES.TryStatement) {
+		if (node.finalizer && blockAlwaysTerminates(node.finalizer)) return true;
+		if (!blockAlwaysTerminates(node.block)) return false;
+		if (!node.handler) return true;
+		return blockAlwaysTerminates(node.handler.body);
+	}
+	return false;
+}
+function collectIntroducedOrAssignedNames(stmt) {
+	const set = /* @__PURE__ */ new Set();
+	const s = unwrapExport(stmt);
+	if (s.type === AST_NODE_TYPES.VariableDeclaration) for (const decl of s.declarations) collectBindingNames(decl.id, set);
+	else if (s.type === AST_NODE_TYPES.FunctionDeclaration && s.id) set.add(s.id.name);
+	else if (s.type === AST_NODE_TYPES.ClassDeclaration && s.id) set.add(s.id.name);
+	else if (s.type === AST_NODE_TYPES.TSInterfaceDeclaration) set.add(s.id.name);
+	else if (s.type === AST_NODE_TYPES.ExpressionStatement) {
+		const expr = s.expression;
+		if (expr.type === AST_NODE_TYPES.AssignmentExpression) collectAssignmentRoots(expr.left, set);
+		else if (expr.type === AST_NODE_TYPES.UpdateExpression && expr.argument.type === AST_NODE_TYPES.Identifier) set.add(expr.argument.name);
+	}
+	return set;
+}
+function collectBindingNames(node, set) {
+	if (!node) return;
+	switch (node.type) {
+		case AST_NODE_TYPES.Identifier:
+			set.add(node.name);
+			break;
+		case AST_NODE_TYPES.ObjectPattern:
+			for (const prop of node.properties) if (prop.type === AST_NODE_TYPES.Property) collectBindingNames(prop.value, set);
+			else collectBindingNames(prop.argument, set);
+			break;
+		case AST_NODE_TYPES.ArrayPattern:
+			for (const el of node.elements) if (el) collectBindingNames(el, set);
+			break;
+		case AST_NODE_TYPES.RestElement:
+			collectBindingNames(node.argument, set);
+			break;
+		case AST_NODE_TYPES.AssignmentPattern:
+			collectBindingNames(node.left, set);
+			break;
+	}
+}
+function collectAssignmentRoots(target, set) {
+	if (target.type === AST_NODE_TYPES.Identifier) set.add(target.name);
+	else if (target.type === AST_NODE_TYPES.MemberExpression) {
+		let root = target;
+		while (root.type === AST_NODE_TYPES.MemberExpression) root = root.object;
+		if (root.type === AST_NODE_TYPES.Identifier) set.add(root.name);
+		else if (root.type === AST_NODE_TYPES.ThisExpression) set.add("this");
+	} else if (target.type === AST_NODE_TYPES.ObjectPattern || target.type === AST_NODE_TYPES.ArrayPattern) collectBindingNames(target, set);
+}
+function collectReferencedNames(root, sourceCode) {
+	const set = /* @__PURE__ */ new Set();
+	walk(root, (node) => {
+		if (node.type === AST_NODE_TYPES.Identifier && !isDeclarationOrPropertyKey(node)) {
+			if (resolvesOutsideRoot(node, root, sourceCode)) set.add(node.name);
+		} else if (node.type === AST_NODE_TYPES.ThisExpression) {
+			if (thisResolvesOutsideRoot(node, root)) set.add("this");
+		} else if (node.type === AST_NODE_TYPES.JSXIdentifier && isJsxComponentIdentifier(node)) {
+			if (resolvesOutsideRoot(node, root, sourceCode)) set.add(node.name);
+		}
+	});
+	return set;
+}
+function resolvesOutsideRoot(idNode, root, sourceCode) {
+	let scope = sourceCode.getScope(idNode);
+	while (scope) {
+		const variable = scope.variables.find((v) => v.name === idNode.name);
+		if (variable) {
+			for (const def of variable.defs) if (isInSubtree(def.node, root)) return false;
+			return true;
+		}
+		scope = scope.upper;
+	}
+	return true;
+}
+function thisResolvesOutsideRoot(thisNode, root) {
+	let p = parentOf(thisNode);
+	while (p) {
+		if (p.type === AST_NODE_TYPES.FunctionDeclaration || p.type === AST_NODE_TYPES.FunctionExpression) return !isInSubtree(p, root);
+		p = parentOf(p);
+	}
+	return true;
+}
+function isJsxComponentIdentifier(node) {
+	if (!/^[A-Z]/.test(node.name)) return false;
+	const parent = node.parent;
+	if (parent.type === AST_NODE_TYPES.JSXOpeningElement && parent.name === node) return true;
+	if (parent.type === AST_NODE_TYPES.JSXClosingElement && parent.name === node) return true;
+	if (parent.type === AST_NODE_TYPES.JSXMemberExpression && parent.object === node) return true;
+	return false;
+}
+function isInSubtree(node, root) {
+	let cur = node;
+	while (cur) {
+		if (cur === root) return true;
+		cur = parentOf(cur);
+	}
+	return false;
+}
+function isDeclarationOrPropertyKey(idNode) {
+	const parent = idNode.parent;
+	if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.id === idNode) return true;
+	if (FN_DECL_TYPES.has(parent.type) && "id" in parent && parent.id === idNode) return true;
+	if ((parent.type === AST_NODE_TYPES.ClassDeclaration || parent.type === AST_NODE_TYPES.ClassExpression) && parent.id === idNode) return true;
+	if (parent.type === AST_NODE_TYPES.MemberExpression && parent.property === idNode && !parent.computed) return true;
+	if (parent.type === AST_NODE_TYPES.MethodDefinition && parent.key === idNode && !parent.computed) return true;
+	if (parent.type === AST_NODE_TYPES.PropertyDefinition && parent.key === idNode && !parent.computed) return true;
+	if (IMPORT_SPECIFIER_TYPES.has(parent.type) && "local" in parent && parent.local === idNode) return true;
+	if (parent.type === AST_NODE_TYPES.Property && parent.key === idNode && !parent.computed && !parent.shorthand) return true;
+	if (isInBindingPosition(idNode)) return true;
+	return false;
+}
+function isInBindingPosition(idNode) {
+	let cur = idNode;
+	let p = parentOf(cur);
+	while (p) {
+		if (FN_DECL_TYPES.has(p.type) && "params" in p && Array.isArray(p.params) && p.params.includes(cur)) return true;
+		if (p.type === AST_NODE_TYPES.ObjectPattern || p.type === AST_NODE_TYPES.ArrayPattern) return true;
+		if (p.type === AST_NODE_TYPES.Property) {
+			if (p.computed && p.key === cur) return false;
+			if (!p.shorthand && p.value !== cur) return false;
+			cur = p;
+			p = parentOf(p);
+			continue;
+		}
+		if (p.type === AST_NODE_TYPES.AssignmentPattern) {
+			if (p.right === cur) return false;
+			cur = p;
+			p = parentOf(p);
+			continue;
+		}
+		if (p.type === AST_NODE_TYPES.RestElement) {
+			cur = p;
+			p = parentOf(p);
+			continue;
+		}
+		return false;
+	}
+	return false;
+}
+function sameJsxParagraph(prev, next, leading) {
+	const firstLeading = leading[0];
+	const lastLeading = leading[leading.length - 1];
+	if (firstLeading && lastLeading && lastLeading.loc.end.line > firstLeading.loc.start.line) return false;
+	if (siblingsIncludeLiteralText(next)) return true;
+	return !(isMultiLine(prev) || isMultiLine(next));
+}
+function isCommentOnlyContainer(child) {
+	return child.type === AST_NODE_TYPES.JSXExpressionContainer && child.expression.type === AST_NODE_TYPES.JSXEmptyExpression;
+}
+function siblingsIncludeLiteralText(node) {
+	const parent = parentOf(node);
+	if (!parent || parent.type !== AST_NODE_TYPES.JSXElement && parent.type !== AST_NODE_TYPES.JSXFragment) return false;
+	for (const sibling of parent.children) {
+		if (sibling.type === AST_NODE_TYPES.JSXText && sibling.value.trim() !== "") return true;
+		if (sibling.type === AST_NODE_TYPES.JSXExpressionContainer && expressionYieldsStringLiteral(sibling.expression)) return true;
+	}
+	return false;
+}
+function expressionYieldsStringLiteral(expr) {
+	if (expr.type === AST_NODE_TYPES.Literal) return typeof expr.value === "string";
+	if (expr.type === AST_NODE_TYPES.TemplateLiteral) return true;
+	if (expr.type === AST_NODE_TYPES.LogicalExpression) return expressionYieldsStringLiteral(expr.right);
+	if (expr.type === AST_NODE_TYPES.ConditionalExpression) return expressionYieldsStringLiteral(expr.consequent) || expressionYieldsStringLiteral(expr.alternate);
+	return false;
+}
+function walk(node, fn) {
+	if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+	fn(node);
+	const obj = node;
+	for (const key of Object.keys(obj)) {
+		if (SKIP_KEYS.has(key)) continue;
+		if (key === "body" && OPAQUE_BODY_TYPES.has(node.type)) continue;
+		const child = obj[key];
+		if (Array.isArray(child)) for (const c of child) walk(c, fn);
+		else walk(child, fn);
+	}
+}
+function isMultiLine(node) {
+	return node.loc.start.line !== node.loc.end.line;
+}
+function hasMultiLineLeadingComment(node, sourceCode) {
+	const comments = sourceCode.getCommentsBefore(node);
+	if (comments.length === 0) return false;
+	const first = comments[0];
+	const last = comments[comments.length - 1];
+	return Boolean(first && last && last.loc.end.line > first.loc.start.line);
+}
+
+//#endregion
+//#region src/index.ts
+const plugin = {
+	meta: {
+		name: "@utilfirst/eslint-plugin",
+		version: "0.1.0"
+	},
+	rules: { "consistent-blank-lines": consistentBlankLines },
+	configs: {}
+};
+plugin.configs.recommended = {
+	plugins: { utilfirst: plugin },
+	rules: { "utilfirst/consistent-blank-lines": "error" }
+};
+var src_default = plugin;
+
+//#endregion
+export { src_default as default };

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@utilfirst/eslint-plugin",
+  "version": "0.1.0",
+  "description": "Shared ESLint rules for utilfirst projects",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
+  "homepage": "https://github.com/utilfirst/utilfirst-eslint-plugin#readme",
+  "bugs": "https://github.com/utilfirst/utilfirst-eslint-plugin/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/utilfirst/utilfirst-eslint-plugin.git"
+  },
+  "license": "MIT",
+  "author": "Ayan Yenbekbay <ayan.yenb@gmail.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "fix": "pnpm run --sequential '/^fix:[^:]+$/'",
+    "fix:eslint": "pnpm run lint:eslint --fix",
+    "fix:prettier": "pnpm run lint:prettier --write",
+    "lint": "pnpm run --sequential '/^lint:[^:]+$/'",
+    "lint:eslint": "eslint .",
+    "lint:prettier": "prettier --check .",
+    "lint:publint": "publint",
+    "lint:typecheck": "tsc --pretty --noEmit",
+    "prepack": "pnpm run build",
+    "setup-hooks": "simple-git-hooks",
+    "test": "vitest run"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm exec lint-staged && pnpm run lint:typecheck"
+  },
+  "lint-staged": {
+    "*": "prettier --ignore-unknown --write",
+    "*.{js,cjs,mjs,ts,tsx}": "eslint --fix"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.59.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.1",
+    "@typescript-eslint/rule-tester": "^8.59.3",
+    "eslint": "^10.3.0",
+    "lint-staged": "^17.0.4",
+    "prettier": "^3.8.3",
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "prettier-plugin-packagejson": "^3.0.2",
+    "prettier-plugin-sh": "^0.18.1",
+    "prettier-plugin-sort-json": "^4.2.0",
+    "publint": "^0.3.16",
+    "simple-git-hooks": "^2.13.1",
+    "tsdown": "^0.18.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.3",
+    "vitest": "^4.0.7"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0 || ^10.0.0"
+  },
+  "packageManager": "pnpm@11.0.9",
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}