@utilfirst/eslint-plugin 0.2.0 → 0.3.0

package/LICENSE

@@ -22,8 +22,9 @@ SOFTWARE.
 
 Third-party notices
 
-The files under `src/rules/` other than `consistent-blank-lines.ts` and the
-files under `src/shared/` include adapted work from anti-slop:
+Portions of this software are adapted from anti-slop
+(https://github.com/dmmulroy/anti-slop) and are used under the following
+license:
 
 MIT License
 

package/README.md

@@ -109,29 +109,29 @@ export default [
 
 [`docs/rules.md`](./docs/rules.md) explains the policy boundary and expected replacement for every rule. The implementations and colocated tests remain the executable behavior owners.
 
-| Rule                                                                                    | Description                                                                           |
-| --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
-| [`consistent-blank-lines`](./docs/rules/consistent-blank-lines.md)                      | Insert blank lines between statement-list and JSXChild items that start a new thought |
-| [`no-chained-type-assertions`](./docs/rules.md#type-evidence)                           | Reject chained TypeScript assertions                                                  |
-| [`no-conditional-undefined-properties`](./docs/rules.md#object-and-api-construction)    | Reject conditional undefined object properties                                        |
-| [`no-enum-declarations`](./docs/rules.md#object-and-api-construction)                   | Reject repository-owned enums other than ambient declarations                         |
-| [`no-known-value-widening`](./docs/rules.md#type-evidence)                              | Reject known values widened into broad target types                                   |
-| [`no-module-mocking`](./docs/rules.md#ownership-and-tests)                              | Reject Vitest and Jest mocking of repository-owned modules                            |
-| [`no-object-parameters`](./docs/rules.md#boundary-contracts)                            | Reject `object` function parameters                                                   |
-| [`no-positional-boolean-parameters`](./docs/rules.md#object-and-api-construction)       | Reject positional boolean flags on named functions and methods                        |
-| [`no-reflect-apply`](./docs/rules.md#object-and-api-construction)                       | Reject `Reflect.apply`                                                                |
-| [`no-reflect-get`](./docs/rules.md#object-and-api-construction)                         | Reject `Reflect.get`                                                                  |
-| [`no-unknown-parameters`](./docs/rules.md#boundary-contracts)                           | Keep explicit `unknown` parameters at decoding boundaries                             |
-| [`no-unknown-returns`](./docs/rules.md#boundary-contracts)                              | Reject `unknown` return contracts                                                     |
-| [`no-unknown-type-aliases`](./docs/rules.md#boundary-contracts)                         | Reject type aliases that resolve to `unknown`                                         |
-| [`no-unsafe-dictionary-type`](./docs/rules.md#boundary-contracts)                       | Reject dictionary contracts with broad value types                                    |
-| [`no-unhandled-detached-promises`](./docs/rules.md#async-errors)                        | Require rejection handling on `void`-marked detached call chains                      |
-| [`no-widen-then-assert`](./docs/rules.md#type-evidence)                                 | Reject const flows that widen a known value before narrowing it                       |
-| [`prefer-options-parameter`](./docs/rules.md#object-and-api-construction)               | Require options objects for named functions and methods with three or more inputs     |
-| [`prefer-switch-discriminator-chain`](./docs/rules.md#object-and-api-construction)      | Require a switch for four or more equality branches on one discriminator              |
-| [`prefer-top-level-function-declarations`](./docs/rules.md#object-and-api-construction) | Require declarations for direct top-level function bindings and default exports       |
-| [`require-lint-suppression-reason`](./docs/rules.md#lint-policy)                        | Require a forcing reason on lint disable directives                                   |
-| [`require-safety-comment-for-type-assertion`](./docs/rules.md#type-evidence)            | Require one `SAFETY:` comment for each outermost non-const assertion                  |
+| Rule                                                                                    | Description                                                                       |
+| --------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| [`consistent-blank-lines`](./docs/rules/consistent-blank-lines.md)                      | Apply tight, separate, or preserved gaps between statements and JSX children      |
+| [`no-chained-type-assertions`](./docs/rules.md#type-evidence)                           | Reject chained TypeScript assertions                                              |
+| [`no-conditional-undefined-properties`](./docs/rules.md#object-and-api-construction)    | Reject conditional undefined object properties                                    |
+| [`no-enum-declarations`](./docs/rules.md#object-and-api-construction)                   | Reject repository-owned enums other than ambient declarations                     |
+| [`no-known-value-widening`](./docs/rules.md#type-evidence)                              | Reject known values widened into broad target types                               |
+| [`no-module-mocking`](./docs/rules.md#ownership-and-tests)                              | Reject Vitest and Jest mocking of repository-owned modules                        |
+| [`no-object-parameters`](./docs/rules.md#boundary-contracts)                            | Reject `object` function parameters                                               |
+| [`no-positional-boolean-parameters`](./docs/rules.md#object-and-api-construction)       | Reject positional boolean flags on named functions and methods                    |
+| [`no-reflect-apply`](./docs/rules.md#object-and-api-construction)                       | Reject `Reflect.apply`                                                            |
+| [`no-reflect-get`](./docs/rules.md#object-and-api-construction)                         | Reject `Reflect.get`                                                              |
+| [`no-unknown-parameters`](./docs/rules.md#boundary-contracts)                           | Keep explicit `unknown` parameters at decoding boundaries                         |
+| [`no-unknown-returns`](./docs/rules.md#boundary-contracts)                              | Reject `unknown` return contracts                                                 |
+| [`no-unknown-type-aliases`](./docs/rules.md#boundary-contracts)                         | Reject type aliases that resolve to `unknown`                                     |
+| [`no-unsafe-dictionary-type`](./docs/rules.md#boundary-contracts)                       | Reject dictionary contracts with broad value types                                |
+| [`no-unhandled-detached-promises`](./docs/rules.md#async-errors)                        | Require rejection handling on `void`-marked detached call chains                  |
+| [`no-widen-then-assert`](./docs/rules.md#type-evidence)                                 | Reject const flows that widen a known value before narrowing it                   |
+| [`prefer-options-parameter`](./docs/rules.md#object-and-api-construction)               | Require options objects for named functions and methods with three or more inputs |
+| [`prefer-switch-discriminator-chain`](./docs/rules.md#object-and-api-construction)      | Require a switch for four or more equality branches on one discriminator          |
+| [`prefer-top-level-function-declarations`](./docs/rules.md#object-and-api-construction) | Require declarations for direct top-level function bindings and default exports   |
+| [`require-lint-suppression-reason`](./docs/rules.md#lint-policy)                        | Require a forcing reason on lint disable directives                               |
+| [`require-safety-comment-for-type-assertion`](./docs/rules.md#type-evidence)            | Require one `SAFETY:` comment for each outermost non-const assertion              |
 
 ## Attribution
 

package/dist/index.js

@@ -3,7 +3,7 @@ import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 import { z } from "zod";
 
 //#region package.json
-var version = "0.2.0";
+var version = "0.3.0";
 
 //#endregion
 //#region src/rules/consistent-blank-lines.ts
@@ -24,14 +24,8 @@ const IMPORT_SPECIFIER_TYPES = new Set([
 	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,
+const OPAQUE_BODY_TYPES = new Set([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.ClassDeclaration]);
+const EXPRESSION_CONTINUATION_TYPES = new Set([
 	AST_NODE_TYPES.IfStatement,
 	AST_NODE_TYPES.ReturnStatement,
 	AST_NODE_TYPES.ThrowStatement,
@@ -43,6 +37,7 @@ const HEAVY_NEXT_TYPES = new Set([
 	AST_NODE_TYPES.FunctionDeclaration,
 	AST_NODE_TYPES.ClassDeclaration,
 	AST_NODE_TYPES.TSInterfaceDeclaration,
+	AST_NODE_TYPES.TSDeclareFunction,
 	AST_NODE_TYPES.ReturnStatement,
 	AST_NODE_TYPES.ThrowStatement
 ]);
@@ -59,34 +54,42 @@ const consistentBlankLines = {
 	meta: {
 		type: "layout",
 		docs: {
-			description: "Insert blank lines between statement-list and JSXChild items that start a new thought.",
+			description: "Apply explicit gap policies between adjacent statement-list and JSXChild items.",
 			url: "https://github.com/utilfirst/utilfirst-eslint-plugin/blob/main/docs/rules/consistent-blank-lines.md"
 		},
 		fixable: "whitespace",
 		defaultOptions: [],
 		schema: [],
 		messages: {
-			extra: "Unexpected blank line between items that continue the same paragraph.",
-			missing: "Expected a blank line between items that start a new paragraph."
+			extra: "Unexpected blank line between items that require a tight gap.",
+			missing: "Expected one blank line between items that require separation."
 		}
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
+		const lineBreak = sourceCode.text.includes("\r\n") ? "\r\n" : "\n";
 		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({
-					effectiveStart: sourceCode.getCommentsBefore(next)[0] ?? next,
-					isSameParagraph: () => sameParagraph({
+				if (prev && next) {
+					const { effectiveEnd, leadingComments } = partitionStatementComments({
+						comments: sourceCode.getCommentsBefore(next),
+						prev
+					});
+					checkPair({
+						effectiveEnd,
+						effectiveStart: leadingComments[0] ?? next,
 						next,
-						prev,
-						sourceCode
-					}),
-					next,
-					prev,
-					shouldPreserveExtra: () => isImportPair(prev, next) || isReExport(prev) && isReExport(next) || isExpressionStatementPair(prev, next)
-				});
+						policy: statementGapPolicy({
+							leadingComments,
+							next,
+							prev,
+							sourceCode
+						}),
+						prev
+					});
+				}
 			}
 		}
 		function checkJsxChildren(children) {
@@ -111,28 +114,36 @@ const consistentBlankLines = {
 					const { node: prev } = prevSibling;
 					const { leading, node: next } = nextSibling;
 					checkPair({
+						effectiveEnd: prev,
 						effectiveStart: leading[0] ?? next,
-						isSameParagraph: () => sameJsxParagraph({
+						next,
+						policy: jsxGapPolicy({
 							leading,
 							next,
 							prev
 						}),
-						next,
-						prev,
-						shouldPreserveExtra: () => false
+						prev
 					});
 				}
 			}
 		}
-		function checkPair({ effectiveStart, isSameParagraph, next, prev, shouldPreserveExtra }) {
-			const prevEndLine = prev.loc.end.line;
+		function checkPair({ effectiveEnd, effectiveStart, next, policy, prev }) {
+			if (policy === "preserve") return;
+			const prevEndLine = effectiveEnd.loc.end.line;
 			const nextStartLine = effectiveStart.loc.start.line;
-			if (nextStartLine - prevEndLine < 1) return;
-			const isPaddingRequired = !isSameParagraph();
+			if (nextStartLine === prevEndLine) {
+				if (policy === "tight") return;
+				const indentation = indentationOf(prev, sourceCode);
+				context.report({
+					node: next,
+					messageId: "missing",
+					fix: (fixer) => fixer.replaceTextRange([effectiveEnd.range[1], effectiveStart.range[0]], `${lineBreak}${lineBreak}${indentation}`)
+				});
+				return;
+			}
 			const paddingCount = nextStartLine - prevEndLine - 1;
-			const targetPadding = isPaddingRequired ? 1 : 0;
+			const targetPadding = policy === "separate" ? 1 : 0;
 			if (paddingCount === targetPadding) return;
-			if (paddingCount > targetPadding && shouldPreserveExtra()) return;
 			context.report({
 				node: next,
 				messageId: paddingCount < targetPadding ? "missing" : "extra",
@@ -145,7 +156,7 @@ const consistentBlankLines = {
 						line: nextStartLine,
 						column: 0
 					});
-					return fixer.replaceTextRange([start, end], "\n".repeat(targetPadding));
+					return fixer.replaceTextRange([start, end], lineBreak.repeat(targetPadding));
 				}
 			});
 		}
@@ -171,25 +182,61 @@ const consistentBlankLines = {
 		};
 	}
 };
-function sameParagraph({ next, prev, sourceCode }) {
-	if (hasMultiLineLeadingComment(next, sourceCode)) return false;
-	const prevHook = isHookStatement(prev);
-	const nextHook = isHookStatement(next);
-	if (prevHook || nextHook) return prevHook && nextHook && isMatchingVarDeclPair({
+function partitionStatementComments({ comments, prev }) {
+	let effectiveEnd = prev;
+	let leadingIndex = 0;
+	while (true) {
+		const comment = comments[leadingIndex];
+		if (!comment || comment.loc.start.line !== effectiveEnd.loc.end.line) break;
+		effectiveEnd = comment;
+		leadingIndex++;
+	}
+	return {
+		effectiveEnd,
+		leadingComments: comments.slice(leadingIndex)
+	};
+}
+function indentationOf(node, sourceCode) {
+	const lineStart = sourceCode.getIndexFromLoc({
+		line: node.loc.start.line,
+		column: 0
+	});
+	const linePrefix = sourceCode.text.slice(lineStart, node.range[0]);
+	return /^[\t ]*/u.exec(linePrefix)?.[0] ?? "";
+}
+function statementGapPolicy({ leadingComments, next, prev, sourceCode }) {
+	if (itemsSpanMultipleLines(leadingComments)) return "separate";
+	const prevHook = hookStatementOf(prev);
+	const nextHook = hookStatementOf(next);
+	if (prevHook || nextHook) return prevHook?.kind === "variable" && nextHook?.kind === "variable" && declarationsHaveSameShell({
+		next,
+		prev
+	}) ? "tight" : "separate";
+	if (isImportPair(prev, next) || isReExport(prev) && isReExport(next) || isExpressionStatementPair(prev, next)) return "preserve";
+	if (sharesNameFlow({
 		next,
 		prev,
-		shouldMatchInitializers: false
-	});
-	return sharesNameFlow({
+		sourceCode
+	}) || statementsRequireTightGap({
 		next,
 		prev,
 		sourceCode
-	}) || statementsBelongTogether(prev, next);
+	})) return "tight";
+	return "separate";
 }
-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 hookStatementOf(stmt) {
+	const declaration = unwrapExport(stmt);
+	if (declaration.type === AST_NODE_TYPES.VariableDeclaration && declaration.declarations.length === 1 && isHookCall(declaration.declarations[0].init)) return { kind: "variable" };
+	if (declaration.type === AST_NODE_TYPES.ExpressionStatement && isHookCall(declaration.expression)) return { kind: "expression" };
+	return null;
+}
+function declarationsHaveSameShell({ next, prev }) {
+	const previousDeclaration = unwrapExport(prev);
+	const nextDeclaration = unwrapExport(next);
+	return previousDeclaration.type === AST_NODE_TYPES.VariableDeclaration && nextDeclaration.type === AST_NODE_TYPES.VariableDeclaration && isExported(prev) === isExported(next) && !isMultiLine(prev) && !isMultiLine(next) && previousDeclaration.declarations.length === 1 && nextDeclaration.declarations.length === 1;
+}
+function isExported(stmt) {
+	return stmt.type === AST_NODE_TYPES.ExportNamedDeclaration || stmt.type === AST_NODE_TYPES.ExportDefaultDeclaration;
 }
 function sharesNameFlow({ next, prev, sourceCode }) {
 	if (isMultiLine(prev)) return false;
@@ -205,21 +252,17 @@ function sharesNameFlow({ next, prev, sourceCode }) {
 function isHookCall(node) {
 	return node?.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.Identifier && /^use[A-Z]/u.test(node.callee.name);
 }
-function statementsBelongTogether(prev, next) {
-	if (isImportPair(prev, next)) return true;
-	if (isReExport(prev) && isReExport(next)) return true;
+function statementsRequireTightGap({ next, prev, sourceCode }) {
 	if (isMatchingVarDeclPair({
 		next,
-		prev
+		prev,
+		sourceCode
 	})) return true;
 	if (isMatchingTypeAliasPair(prev, next)) return true;
-	if (FLOW_PREV_TYPES.has(prev.type) && FLOW_NEXT_TYPES.has(next.type)) {
+	if (prev.type === AST_NODE_TYPES.IfStatement && next.type === AST_NODE_TYPES.IfStatement) return !(isGuardIf(prev) && !isGuardIf(next));
+	if (prev.type === AST_NODE_TYPES.ExpressionStatement && EXPRESSION_CONTINUATION_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 !(next.type === AST_NODE_TYPES.IfStatement && isGuardIf(next));
 	}
 	return false;
 }
@@ -232,56 +275,47 @@ function isExpressionStatementPair(prev, next) {
 function isReExport(stmt) {
 	return stmt.type === AST_NODE_TYPES.ExportNamedDeclaration && stmt.source !== null || stmt.type === AST_NODE_TYPES.ExportAllDeclaration;
 }
-function isMatchingVarDeclPair({ next, prev, shouldMatchInitializers = true }) {
+function isMatchingVarDeclPair({ next, prev, sourceCode }) {
 	const previousDeclaration = unwrapExport(prev);
 	const nextDeclaration = unwrapExport(next);
 	if (previousDeclaration.type !== AST_NODE_TYPES.VariableDeclaration || nextDeclaration.type !== AST_NODE_TYPES.VariableDeclaration) return false;
 	if (!isConstOrLet(previousDeclaration) || !isConstOrLet(nextDeclaration)) return false;
 	if (isMultiLine(prev) || isMultiLine(next)) return false;
 	if (previousDeclaration.declarations.length !== 1 || nextDeclaration.declarations.length !== 1) return false;
-	if (shouldMatchInitializers && !initializersBelongTogether(previousDeclaration.declarations[0].init, nextDeclaration.declarations[0].init)) return false;
-	return prev.type === AST_NODE_TYPES.ExportNamedDeclaration === (next.type === AST_NODE_TYPES.ExportNamedDeclaration);
+	if (!initializersBelongTogether({
+		nextInit: nextDeclaration.declarations[0].init,
+		prevInit: previousDeclaration.declarations[0].init,
+		sourceCode
+	})) return false;
+	return isExported(prev) === isExported(next);
 }
 function isMatchingTypeAliasPair(prev, next) {
 	const previousDeclaration = unwrapExport(prev);
 	const nextDeclaration = unwrapExport(next);
 	if (previousDeclaration.type !== AST_NODE_TYPES.TSTypeAliasDeclaration || nextDeclaration.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);
+	return isExported(prev) === isExported(next);
 }
 function unwrapExport(stmt) {
 	if (stmt.type === AST_NODE_TYPES.ExportNamedDeclaration && stmt.declaration) return stmt.declaration;
+	if (stmt.type === AST_NODE_TYPES.ExportDefaultDeclaration) return stmt.declaration;
 	return stmt;
 }
 function isConstOrLet(decl) {
 	return decl.kind === "const" || decl.kind === "let";
 }
-function initializersBelongTogether(prevInit, nextInit) {
-	const prevCall = asCall(prevInit);
-	const nextCall = asCall(nextInit);
-	if (prevCall && nextCall) return calleesEqual(prevCall.callee, nextCall.callee);
-	if (prevCall || nextCall) return false;
+function initializersBelongTogether({ nextInit, prevInit, sourceCode }) {
+	const previousCallIdentity = callIdentityOf(prevInit, sourceCode);
+	const nextCallIdentity = callIdentityOf(nextInit, sourceCode);
+	if (previousCallIdentity !== null && nextCallIdentity !== null) return previousCallIdentity === nextCallIdentity;
+	if (previousCallIdentity !== null || nextCallIdentity !== null) return false;
 	return true;
 }
-function asCall(expr) {
+function callIdentityOf(expr, sourceCode) {
 	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;
-		if (a.computed && a.property.type === AST_NODE_TYPES.Identifier && b.property.type === AST_NODE_TYPES.Identifier) return a.property.name === b.property.name;
-		if (a.computed && a.property.type === AST_NODE_TYPES.Literal && b.property.type === AST_NODE_TYPES.Literal) return a.property.value === b.property.value;
-		return false;
-	}
-	if (a.type === AST_NODE_TYPES.CallExpression && b.type === AST_NODE_TYPES.CallExpression) return calleesEqual(a.callee, b.callee);
-	return false;
+	const call = expr.type === AST_NODE_TYPES.ChainExpression ? expr.expression : expr;
+	if (call.type !== AST_NODE_TYPES.CallExpression) return null;
+	return `${call.optional ? "optional" : "direct"}:${sourceCode.getText(call.callee)}`;
 }
 function isGuardIf(stmt) {
 	return stmt.type === AST_NODE_TYPES.IfStatement && blockAlwaysTerminates(stmt.consequent);
@@ -311,6 +345,7 @@ function collectIntroducedOrAssignedNames(stmt) {
 	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.TSDeclareFunction && s.id) 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);
@@ -405,11 +440,17 @@ function isInSubtree(node, root) {
 }
 function isDeclarationOrPropertyKey(idNode) {
 	const parent = idNode.parent;
+	if (parent.type === AST_NODE_TYPES.LabeledStatement && parent.label === idNode || (parent.type === AST_NODE_TYPES.BreakStatement || parent.type === AST_NODE_TYPES.ContinueStatement) && parent.label === idNode) return true;
 	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 (IMPORT_SPECIFIER_TYPES.has(parent.type) && "local" in parent && parent.local === idNode) return true;
+	if (parent.type === AST_NODE_TYPES.ImportSpecifier) return true;
+	if (parent.type === AST_NODE_TYPES.ExportSpecifier && parent.exported === idNode && parent.local !== idNode) return true;
+	if (parent.type === AST_NODE_TYPES.MetaProperty) return true;
+	if (parent.type === AST_NODE_TYPES.TSQualifiedName && parent.right === idNode) return true;
+	if ((parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition || parent.type === AST_NODE_TYPES.AccessorProperty || parent.type === AST_NODE_TYPES.TSMethodSignature || parent.type === AST_NODE_TYPES.TSPropertySignature) && parent.key === idNode && !parent.computed) 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;
@@ -443,35 +484,26 @@ function isInBindingPosition(idNode) {
 	}
 	return false;
 }
-function sameJsxParagraph({ leading, next, prev }) {
-	const firstLeading = leading[0];
-	const lastLeading = leading.at(-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 jsxGapPolicy({ leading, next, prev }) {
+	if (itemsSpanMultipleLines(leading)) return "separate";
+	if (isLiteralTextChild(prev) || isLiteralTextChild(next)) return "tight";
+	return isMultiLine(prev) || isMultiLine(next) ? "separate" : "tight";
 }
 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 isLiteralTextChild(child) {
+	if (child.type === AST_NODE_TYPES.JSXText) return child.value.trim() !== "";
+	return child.type === AST_NODE_TYPES.JSXExpressionContainer && expressionProducesTextOrNothing(child.expression);
 }
-function expressionYieldsStringLiteral(expr) {
-	if (expr.type === AST_NODE_TYPES.Literal) return isString$2(expr.value);
+function expressionProducesTextOrNothing(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);
+	if (expr.type === AST_NODE_TYPES.TSAsExpression || expr.type === AST_NODE_TYPES.TSTypeAssertion || expr.type === AST_NODE_TYPES.TSNonNullExpression || expr.type === AST_NODE_TYPES.TSSatisfiesExpression) return expressionProducesTextOrNothing(expr.expression);
+	if (expr.type === AST_NODE_TYPES.LogicalExpression && expr.operator === "&&") return expressionProducesTextOrNothing(expr.right);
+	if (expr.type === AST_NODE_TYPES.ConditionalExpression) return expressionProducesTextOrNothing(expr.consequent) && expressionProducesTextOrNothing(expr.alternate);
 	return false;
 }
-function isString$2(value) {
-	return typeof value === "string";
-}
 function isNode(value) {
 	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
 }
@@ -492,12 +524,11 @@ function walk(node, 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.at(-1);
-	return Boolean(first && last && last.loc.end.line > first.loc.start.line);
+function itemsSpanMultipleLines(items) {
+	const first = items[0];
+	const last = items.at(-1);
+	if (!first || !last) return false;
+	return last.loc.end.line > first.loc.start.line;
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utilfirst/eslint-plugin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Shared lint rules for ESLint and Oxlint",
   "keywords": [
     "eslint",