eslint-plugin-nextfriday 5.0.0 → 5.0.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eslint-plugin-nextfriday
 
+## 5.0.1
+
+### Patch Changes
+
+- [#138](https://github.com/next-friday/eslint-plugin-nextfriday/pull/138) [`28c600d`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/28c600d4746de76f7587e2fb5eab97ec5bdc6658) Thanks [@joetakara](https://github.com/joetakara)! - fix `no-inline-nested-object` scope — the rule now applies only to function-like contexts (call arguments, `new` expressions, `return` statements, arrow implicit returns, and JSX expressions) instead of every object property; module-level data declarations such as route tables, dependency rule arrays, and configuration objects are no longer flagged, eliminating false positives in patterns where Prettier already controls the layout
+
 ## 5.0.0
 
 ### Major Changes

package/docs/rules/NO_INLINE_NESTED_OBJECT.md

@@ -1,96 +1,96 @@
 # no-inline-nested-object
 
-Require object or array values that contain further nested objects or arrays to span multiple lines.
+Require object or array values passed to functions, returned from functions, or used as JSX attributes to span multiple lines when they contain nested objects or arrays.
+
+> This rule is auto-fixable using `--fix`.
 
 ## Rule Details
 
-This rule enforces that when an object property's value is itself an object or array **that contains further nested structures inside**, it must span multiple lines. Flat collections — objects of primitive properties or arrays of simple references — are allowed inline because Prettier already controls their wrapping via `printWidth`.
+This rule applies **only to function-like contexts**:
+
+- Arguments to function calls (`CallExpression`) and constructor calls (`NewExpression`)
+- Values returned from functions (`return` statements)
+- Implicit returns from arrow functions
+- Expressions inside JSX braces (props, children)
+
+When the value passed/returned in one of those contexts is an inline object or array that contains another object or array as a property value or element, the rule requires it to span multiple lines. Flat collections — objects of primitive properties or arrays of simple references — are allowed inline because Prettier already controls their wrapping via `printWidth`.
 
-A "nested structure" is any object or array element/property whose value is another object or array. The rule deliberately ignores depth-1 collections so it does not fight Prettier on simple data and configuration tables.
+The rule deliberately **does not apply to module-level data declarations** (e.g., `const config = { ... }`, route tables, dependency rule arrays). These are static configuration data, not function calls — Prettier handles their layout, and forcing them multiline produces noisy diffs without aiding readability.
 
 ### Why?
 
-Truly nested structures are easy to misread when collapsed onto a single line, and adding or removing an inner element produces noisy diffs. Flat collections do not have the same problem and are best left to Prettier's line-length logic.
+Truly nested structures passed at a call site are easy to misread when collapsed onto a single line, and adding or removing an inner element produces noisy diffs at the call site. The rule does not target data declarations because forcing static configuration arrays/objects onto multiple lines fights Prettier and bloats config files without aiding readability.
 
 ## Examples
 
 ### Incorrect
 
-<!-- prettier-ignore -->
 ```ts
-const obj = {
-  items: [{ a: 1 }, { b: 2 }],
-};
+useState({ a: { b: 1 } });
 ```
 
-<!-- prettier-ignore -->
 ```ts
-const obj = {
-  matrix: [[1, 2], [3, 4]],
-};
+doThing([{ a: 1 }, { b: 2 }]);
 ```
 
 ```ts
-const obj = {
-  layer: { inner: { leaf: 1 } },
-};
+function build() {
+  return { user: { id: 1 } };
+}
 ```
 
 ```ts
-const obj = {
-  wrap: { items: [1, 2, 3] },
-};
+const factory = () => ({ a: { b: 1 } });
+```
+
+```tsx
+const el = <Comp prop={{ a: { b: 1 } }} />;
 ```
 
 ### Correct
 
-<!-- prettier-ignore -->
+Function-context calls expanded onto multiple lines:
+
 ```ts
-const obj = {
-  items: [
-    { a: 1 },
-    { b: 2 },
-  ],
-};
+useState({
+  a: { b: 1 },
+});
 ```
 
 ```ts
-const obj = {
-  layer: {
-    inner: { leaf: 1 },
-  },
-};
+doThing([{ a: 1 }, { b: 2 }]);
 ```
 
-Flat values stay inline:
-
 ```ts
-const obj = {
-  config: { enabled: true, timeout: 5000 },
-  database: { host: "localhost", port: 5432, name: "myapp" },
-};
+function build() {
+  return {
+    user: { id: 1 },
+  };
+}
 ```
 
+Flat values stay inline:
+
 ```ts
-const obj = {
-  options: ["primary", "foreground", "danger", "outline", "ghost", "link"],
-  allow: [target.utils, target.types, target.constants],
-};
+useState({ enabled: true, timeout: 5000 });
+useState([1, 2, 3]);
 ```
 
-Empty nested objects and arrays are allowed inline:
+Module-level data declarations are not checked:
 
+<!-- prettier-ignore -->
 ```ts
-const initialState = {
-  data: {},
-  errors: [],
+const dependencyRules = [
+  { from: source.modules, allow: [{ to: { type: "templates" } }] },
+];
+
+const obj = {
+  items: [{ a: 1 }, { b: 2 }],
+  matrix: [[1, 2], [3, 4]],
+  layer: { inner: { leaf: 1 } },
 };
 ```
 
 ## When Not To Use It
 
-If your team prefers compact single-line nested structures regardless of depth, or if your project has different formatting preferences.
-
-## Fixable
-
-This rule is auto-fixable. Running ESLint with the `--fix` flag will expand inline collections that contain nested structures onto multiple lines.
+If your team prefers compact single-line nested structures at call sites regardless of nesting, or if your project has different formatting preferences.

package/lib/index.cjs

@@ -32,7 +32,7 @@ let emoji_regex = require("emoji-regex");
 emoji_regex = __toESM(emoji_regex, 1);
 //#region package.json
 var name = "eslint-plugin-nextfriday";
-var version = "5.0.0";
+var version = "5.0.1";
 //#endregion
 //#region src/rules/boolean-naming-prefix.ts
 const createRule$26 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`);
@@ -1778,9 +1778,6 @@ const noHelperFunctionInTest = _typescript_eslint_utils.ESLintUtils.RuleCreator(
 //#endregion
 //#region src/rules/no-inline-nested-object.ts
 const createRule$11 = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`);
-function isObjectOrArray(node) {
-	return node.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression || node.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression || node.type === _typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression;
-}
 function getInnerExpression(node) {
 	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression) return getInnerExpression(node.expression);
 	return node;
@@ -1803,7 +1800,7 @@ const noInlineNestedObject = createRule$11({
 	name: "no-inline-nested-object",
 	meta: {
 		type: "layout",
-		docs: { description: "Require object or array values that contain further nested objects or arrays to span multiple lines" },
+		docs: { description: "Require object or array values passed to functions, returned, or used as JSX attributes to span multiple lines when they contain nested objects or arrays" },
 		fixable: "whitespace",
 		messages: { requireMultiline: "Inline collections containing nested objects or arrays should span multiple lines" },
 		schema: []
@@ -1811,32 +1808,54 @@ const noInlineNestedObject = createRule$11({
 	defaultOptions: [],
 	create(context) {
 		const { sourceCode } = context;
-		return { Property(node) {
-			if (!node.value || !isObjectOrArray(node.value)) return;
-			const valueNode = getInnerExpression(node.value);
-			if (valueNode.type !== _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression && valueNode.type !== _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression) return;
-			if (!valueNode.loc) return;
-			if (valueNode.loc.start.line !== valueNode.loc.end.line) return;
-			if (!containsNestedStructure(valueNode)) return;
-			const elements = valueNode.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
+		function checkValue(node) {
+			if (!node) return;
+			const inner = getInnerExpression(node);
+			if (inner.type !== _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression && inner.type !== _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression) return;
+			if (!inner.loc) return;
+			if (inner.loc.start.line !== inner.loc.end.line) return;
+			if (!containsNestedStructure(inner)) return;
+			const elements = inner.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression ? inner.properties : inner.elements;
 			context.report({
-				node: valueNode,
+				node: inner,
 				messageId: "requireMultiline",
 				fix(fixer) {
-					const openBrace = sourceCode.getFirstToken(valueNode);
-					const closeBrace = sourceCode.getLastToken(valueNode);
-					if (!openBrace || !closeBrace) return null;
-					const indent = " ".repeat(node.loc?.start.column ?? 0);
-					const innerIndent = `${indent}  `;
+					const lineIndentMatch = (sourceCode.lines[inner.loc.start.line - 1] ?? "").match(/^(\s*)/);
+					const lineIndent = lineIndentMatch ? lineIndentMatch[1] : "";
+					const innerIndent = `${lineIndent}  `;
 					const elementTexts = elements.filter((el) => el !== null).map((el) => sourceCode.getText(el));
-					const isObject = valueNode.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression;
+					const isObject = inner.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression;
 					const openChar = isObject ? "{" : "[";
 					const closeChar = isObject ? "}" : "]";
-					const newContent = `${openChar}\n${elementTexts.map((text) => `${innerIndent}${text},`).join("\n")}\n${indent}${closeChar}`;
-					return fixer.replaceText(valueNode, newContent);
+					const newContent = `${openChar}\n${elementTexts.map((text) => `${innerIndent}${text},`).join("\n")}\n${lineIndent}${closeChar}`;
+					return fixer.replaceText(inner, newContent);
 				}
 			});
-		} };
+		}
+		function checkArguments(args) {
+			args.forEach((arg) => {
+				if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return;
+				checkValue(arg);
+			});
+		}
+		return {
+			CallExpression(node) {
+				checkArguments(node.arguments);
+			},
+			NewExpression(node) {
+				checkArguments(node.arguments);
+			},
+			ReturnStatement(node) {
+				checkValue(node.argument);
+			},
+			ArrowFunctionExpression(node) {
+				if (node.body.type !== _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) checkValue(node.body);
+			},
+			JSXExpressionContainer(node) {
+				if (node.expression.type === _typescript_eslint_utils.AST_NODE_TYPES.JSXEmptyExpression) return;
+				checkValue(node.expression);
+			}
+		};
 	}
 });
 //#endregion