eslint-plugin-nextfriday 5.0.0 → 5.0.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # eslint-plugin-nextfriday
 
+## 5.0.2
+
+### Patch Changes
+
+- [#141](https://github.com/next-friday/eslint-plugin-nextfriday/pull/141) [`9a9ba41`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/9a9ba415a7a188ec0f0180cefd807e562a489bc8) Thanks [@joetakara](https://github.com/joetakara)! - Expand `enforce-constant-case` to enforce SCREAMING_SNAKE_CASE on RegExp and bigint constants, and refine `new RegExp()` detection to skip dynamic arguments.
+  - RegExp literals (`/foo/`) and `new RegExp("foo", "g")` (all args must be string literals) are now flagged when named in camelCase at global scope.
+  - BigInt literals (`100n`, `-1n`) are now flagged consistently with number literals.
+  - `new RegExp(userInput)` and other non-literal RegExp constructors are intentionally ignored — only statically-constructed patterns are treated as magic values.
+
+## 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/ENFORCE_CONSTANT_CASE.md

@@ -1,23 +1,25 @@
 # enforce-constant-case
 
-Enforce SCREAMING_SNAKE_CASE for global magic-number and magic-text constants.
+Enforce SCREAMING_SNAKE_CASE for global magic-number, magic-text, bigint, and RegExp constants.
 
 ## Rule Details
 
-This rule ensures that global-scope `const` declarations bound to a **magic number** or **magic text** literal use SCREAMING_SNAKE_CASE. The rule scope is intentionally narrow:
+This rule ensures that global-scope `const` declarations bound to a **magic literal** value use SCREAMING_SNAKE_CASE. The rule scope is intentionally narrow:
 
 - A magic text constant is a string literal: `const API_URL = "https://api.example.com"`
 - A magic number constant is a number literal (including a unary `-`/`+` over a numeric literal): `const PAGE_LIMIT = 10`, `const OFFSET = -1`
+- A bigint constant is a bigint literal (including a unary `-`/`+` over a bigint literal): `const BIG_LIMIT = 9007199254740993n`, `const NEGATIVE_BIG = -1n`
+- A RegExp constant is a regex literal, or a `new RegExp(...)` call whose arguments are **all** string literals: `const PHONE_REGEX = /^[0-9]+$/`, `const EMAIL_PATTERN = new RegExp("^.+@.+$", "g")`
 
-Anything else is **not** checked: booleans, RegExp, template literals (static or dynamic), arrays, objects, `as const` assertions, function calls, identifiers, member expressions, JSX. Use whatever name fits the value (`metadata`, `viewport`, `statusMap`, `phoneRegex`, `isEnabled`, etc.) — the rule will not flag it.
+Anything else is **not** checked: booleans, template literals (static or dynamic), arrays, objects, `as const` assertions, function calls, identifiers, member expressions, JSX, and `new RegExp(dynamicValue)` (where the pattern argument is non-literal). Use whatever name fits the value (`metadata`, `viewport`, `statusMap`, `isEnabled`, `dynamicPattern`, etc.) — the rule will not flag it.
 
 Only global scope (top-level of a file) is checked. Local scope constants inside functions are not checked by this rule.
 
 **Config files are exempt.** Files matching `*.config.{ts,mjs,cjs,js}`, `*.rc.*`, `*.setup.*`, `*.spec.*`, `*.test.*`, `.eslintrc*`, `.babelrc*`, and `.prettierrc*` skip this rule entirely. This avoids conflicts with framework conventions that require specific identifier names — e.g. Next.js expects `nextConfig` (not `NEXT_CONFIG`) in `next.config.ts`, Vite expects `config`, Tailwind expects `config`, etc.
 
-### Why magic numbers and magic text only?
+### Why only static literal values?
 
-Reserved framework export names commonly bind to objects (Next.js App Router exports `metadata`, `viewport`, `generateStaticParams`, `dynamic`, `revalidate`, `runtime`, `fetchCache`, `dynamicParams`, `preferredRegion`, `maxDuration`; React Server Components and others have similar patterns). Forcing SCREAMING_SNAKE_CASE on any static-shaped initializer would rename those exports and break framework integration. Restricting the rule to bare number and string literals keeps the convention where it adds value (avoiding magic constants scattered through code) without colliding with framework-owned names.
+Reserved framework export names commonly bind to objects (Next.js App Router exports `metadata`, `viewport`, `generateStaticParams`, `dynamic`, `revalidate`, `runtime`, `fetchCache`, `dynamicParams`, `preferredRegion`, `maxDuration`; React Server Components and others have similar patterns). Forcing SCREAMING_SNAKE_CASE on any static-shaped initializer would rename those exports and break framework integration. Restricting the rule to bare number, string, bigint, and statically-constructed RegExp values keeps the convention where it adds value (avoiding magic constants scattered through code) without colliding with framework-owned names or flagging dynamically-constructed patterns.
 
 ## Examples
 
@@ -29,6 +31,9 @@ const pageLimit = 10;
 const apiBaseUrl = "https://api.example.com";
 const negativeOne = -1;
 const default_theme = "dark";
+const phoneRegex = /^[0-9]{10}$/;
+const emailPattern = new RegExp("^.+@.+$");
+const bigLimit = 9007199254740993n;
 ```
 
 ### Correct
@@ -39,12 +44,15 @@ const PAGE_LIMIT = 10;
 const API_BASE_URL = "https://api.example.com";
 const NEGATIVE_ONE = -1;
 const DEFAULT_THEME = "dark";
+const PHONE_REGEX = /^[0-9]{10}$/;
+const EMAIL_PATTERN = new RegExp("^.+@.+$", "g");
+const BIG_LIMIT = 9007199254740993n;
 
 const isProduction = true;
 const hasAccess = false;
 const featureEnabled = true;
 
-const phoneRegex = /^[0-9]{10}$/;
+const dynamicPattern = new RegExp(userInput);
 const template = `hello world`;
 const skeletonItems = [1, 2, 3, 4, 5];
 const mapStyle = { height: "320px", width: "100%" };

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.2";
 //#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`);
@@ -162,10 +162,15 @@ const SCREAMING_SNAKE_CASE_REGEX$1 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
 const SNAKE_CASE_REGEX = /^[a-z]+_[a-z0-9_]*$/;
 const toScreamingSnakeCase = (str) => str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase();
 const isMagicLiteral = (init) => {
-	if (init.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal) return typeof init.value === "string" || typeof init.value === "number";
+	if (init.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal) return typeof init.value === "string" || typeof init.value === "number" || typeof init.value === "bigint" || "regex" in init;
 	if (init.type === _typescript_eslint_utils.AST_NODE_TYPES.UnaryExpression) {
 		const { argument, operator } = init;
-		return (operator === "-" || operator === "+") && argument.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof argument.value === "number";
+		if (operator !== "-" && operator !== "+") return false;
+		return argument.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && (typeof argument.value === "number" || typeof argument.value === "bigint");
+	}
+	if (init.type === _typescript_eslint_utils.AST_NODE_TYPES.NewExpression) {
+		if (init.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || init.callee.name !== "RegExp") return false;
+		return init.arguments.every((arg) => arg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof arg.value === "string");
 	}
 	return false;
 };
@@ -179,7 +184,7 @@ const enforceConstantCase = createRule$25({
 	name: "enforce-constant-case",
 	meta: {
 		type: "suggestion",
-		docs: { description: "Enforce SCREAMING_SNAKE_CASE for global magic-number and magic-text constants" },
+		docs: { description: "Enforce SCREAMING_SNAKE_CASE for global magic-number, magic-text, bigint, and RegExp constants" },
 		messages: {
 			useScreamingSnakeCase: "Constant '{{ name }}' should use SCREAMING_SNAKE_CASE. Rename to '{{ suggestion }}'.",
 			noSnakeCase: "Global constant '{{ name }}' should not use snake_case. Rename to '{{ suggestion }}'."
@@ -1778,9 +1783,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 +1805,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 +1813,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