eslint-plugin-nextfriday 3.2.0 → 3.2.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eslint-plugin-nextfriday
 
+## 3.2.1
+
+### Patch Changes
+
+- [#120](https://github.com/next-friday/eslint-plugin-nextfriday/pull/120) [`6f56995`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/6f569958e538f23b699fa3ac1cb4743b87e4ab60) Thanks [@joetakara](https://github.com/joetakara)! - `enforce-constant-case` now only flags global `const` declarations bound to a magic number or magic text literal. Object literals, array literals, RegExp, template literals (static or dynamic), `as const` assertions, booleans, and any non-literal initializer are no longer checked. This unblocks Next.js App Router files where reserved exports like `metadata`, `viewport`, `dynamic`, `revalidate`, `runtime`, `fetchCache`, `dynamicParams`, `preferredRegion`, and `maxDuration` are framework-owned and must keep their exact names. The rule scope now matches the documented intent of the plugin's naming convention skill ("top-level constant primitive values") instead of every static-shaped initializer.
+
 ## 3.2.0
 
 ### Minor Changes

package/docs/rules/ENFORCE_CONSTANT_CASE.md

@@ -1,15 +1,24 @@
 # enforce-constant-case
 
-Enforce SCREAMING_SNAKE_CASE for global constant static values.
+Enforce SCREAMING_SNAKE_CASE for global magic-number and magic-text constants.
 
 ## Rule Details
 
-This rule ensures that global-scope `const` declarations with static values use SCREAMING_SNAKE_CASE naming convention. Static values include: string/number/boolean literals, RegExp, static template literals, `as const` assertions, and objects/arrays containing only literal values.
+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:
+
+- 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`
+
+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.
 
 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?
+
+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.
+
 ## Examples
 
 ### Incorrect
@@ -18,10 +27,8 @@ Only global scope (top-level of a file) is checked. Local scope constants inside
 const defaultCover = "/images/default.jpg";
 const pageLimit = 10;
 const apiBaseUrl = "https://api.example.com";
-const template = `hello world`;
-const phoneRegex = /^[0-9]{10}$/;
+const negativeOne = -1;
 const default_theme = "dark";
-export const categories = [{ id: "1" }] as const;
 ```
 
 ### Correct
@@ -30,35 +37,39 @@ export const categories = [{ id: "1" }] as const;
 const DEFAULT_COVER = "/images/default.jpg";
 const PAGE_LIMIT = 10;
 const API_BASE_URL = "https://api.example.com";
-const TEMPLATE = `hello world`;
-const PHONE_REGEX = /^[0-9]{10}$/;
+const NEGATIVE_ONE = -1;
 const DEFAULT_THEME = "dark";
-export const CATEGORIES = [{ id: "1" }] as const;
 
-const SKELETON_ITEMS = [1, 2, 3, 4, 5];
-const MAP_STYLE = { height: "320px", width: "100%" };
-const STATUS_MAP = { ACTIVE: "active" } as const;
-
-// Booleans with standard prefixes (is, has, should, etc.) are exempt
 const isProduction = true;
 const hasAccess = false;
+const featureEnabled = true;
+
+const phoneRegex = /^[0-9]{10}$/;
+const template = `hello world`;
+const skeletonItems = [1, 2, 3, 4, 5];
+const mapStyle = { height: "320px", width: "100%" };
+const statusMap = { ACTIVE: "active" } as const;
+const categories = [{ id: "1" }] as const;
+
+export const metadata: Metadata = { title: "404 - Page Not Found" };
+export const viewport: Viewport = { themeColor: "#fff" };
+export const generateStaticParams = async () => [];
 
-// Template literals with expressions are dynamic, camelCase is fine
 const pendingHref = `/branch/${branch.branchNumber}`;
 
-// Functions and components are not checked
 const handleClick = () => {};
 const MyComponent = () => {};
 
-// Local scope is not checked
 function foo() {
   const maxRetry = 3;
 }
 ```
 
+> Note: Next.js App Router has a few string-valued reserved exports — `dynamic = "force-dynamic"`, `runtime = "edge"`, `fetchCache = "default-cache"`, etc. — and one number-valued one (`revalidate = 60`, `maxDuration = 30`). These remain in scope for this rule because their initializers are bare literals. Disable `nextfriday/enforce-constant-case` for `app/**` and `pages/**` in your own flat config if you use those exports.
+
 ## Configuration
 
-This rule has no options — only severity is configurable (`"error"`, `"warn"`, `"off"`). It pairs with [`no-misleading-constant-case`](./NO_MISLEADING_CONSTANT_CASE.md) so that static globals use `SCREAMING_SNAKE_CASE` while local scopes and dynamic values keep `camelCase`.
+This rule has no options — only severity is configurable (`"error"`, `"warn"`, `"off"`). It pairs with [`no-misleading-constant-case`](./NO_MISLEADING_CONSTANT_CASE.md) so that magic-literal globals use `SCREAMING_SNAKE_CASE` while local scopes and dynamic values keep `camelCase`.
 
 ### Install
 

package/lib/index.cjs

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "3.2.0",
+  version: "3.2.1",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -447,40 +447,14 @@ var createRule3 = import_utils4.ESLintUtils.RuleCreator(
 );
 var SCREAMING_SNAKE_CASE_REGEX = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
 var SNAKE_CASE_REGEX2 = /^[a-z]+_[a-z0-9_]*$/;
-var BOOLEAN_PREFIXES2 = ["is", "has", "should", "can", "did", "will", "was", "are", "does", "had"];
 var toScreamingSnakeCase = (str) => str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase();
-var startsWithBooleanPrefix2 = (name) => BOOLEAN_PREFIXES2.some((prefix) => {
-  if (!name.startsWith(prefix)) {
-    return false;
-  }
-  if (name.length === prefix.length) {
-    return true;
-  }
-  const nextChar = name.charAt(prefix.length);
-  return nextChar === nextChar.toUpperCase() && nextChar !== nextChar.toLowerCase();
-});
-var isBooleanLiteral2 = (init) => init.type === import_utils4.AST_NODE_TYPES.Literal && typeof init.value === "boolean";
-var isAsConstAssertion = (node) => node.type === import_utils4.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils4.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils4.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
-var isStaticValue2 = (init) => {
-  if (isAsConstAssertion(init)) {
-    return true;
-  }
+var isMagicLiteral = (init) => {
   if (init.type === import_utils4.AST_NODE_TYPES.Literal) {
-    return true;
+    return typeof init.value === "string" || typeof init.value === "number";
   }
-  if (init.type === import_utils4.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils4.AST_NODE_TYPES.Literal) {
-    return true;
-  }
-  if (init.type === import_utils4.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
-    return true;
-  }
-  if (init.type === import_utils4.AST_NODE_TYPES.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== import_utils4.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
-  }
-  if (init.type === import_utils4.AST_NODE_TYPES.ObjectExpression) {
-    return init.properties.every(
-      (prop) => prop.type === import_utils4.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
-    );
+  if (init.type === import_utils4.AST_NODE_TYPES.UnaryExpression) {
+    const { argument, operator } = init;
+    return (operator === "-" || operator === "+") && argument.type === import_utils4.AST_NODE_TYPES.Literal && typeof argument.value === "number";
   }
   return false;
 };
@@ -494,13 +468,12 @@ var isGlobalScope2 = (node) => {
   }
   return false;
 };
-var isFunctionOrComponent = (init) => init.type === import_utils4.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils4.AST_NODE_TYPES.FunctionExpression;
 var enforceConstantCase = createRule3({
   name: "enforce-constant-case",
   meta: {
     type: "suggestion",
     docs: {
-      description: "Enforce SCREAMING_SNAKE_CASE for global constant static values"
+      description: "Enforce SCREAMING_SNAKE_CASE for global magic-number and magic-text constants"
     },
     messages: {
       useScreamingSnakeCase: "Constant '{{ name }}' should use SCREAMING_SNAKE_CASE. Rename to '{{ suggestion }}'.",
@@ -522,16 +495,10 @@ var enforceConstantCase = createRule3({
           if (declarator.id.type !== import_utils4.AST_NODE_TYPES.Identifier || !declarator.init) {
             return;
           }
-          if (isFunctionOrComponent(declarator.init)) {
-            return;
-          }
-          if (!isStaticValue2(declarator.init)) {
+          if (!isMagicLiteral(declarator.init)) {
             return;
           }
           const { name } = declarator.id;
-          if (isBooleanLiteral2(declarator.init) && startsWithBooleanPrefix2(name)) {
-            return;
-          }
           if (SNAKE_CASE_REGEX2.test(name)) {
             context.report({
               node: declarator.id,
@@ -2861,9 +2828,9 @@ var createRule38 = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SCREAMING_SNAKE_CASE_REGEX3 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
-var isAsConstAssertion2 = (node) => node.type === import_utils42.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils42.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils42.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
-var isStaticValue3 = (init) => {
-  if (isAsConstAssertion2(init)) {
+var isAsConstAssertion = (node) => node.type === import_utils42.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils42.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils42.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
+var isStaticValue2 = (init) => {
+  if (isAsConstAssertion(init)) {
     return true;
   }
   if (init.type === import_utils42.AST_NODE_TYPES.Literal) {
@@ -2876,11 +2843,11 @@ var isStaticValue3 = (init) => {
     return true;
   }
   if (init.type === import_utils42.AST_NODE_TYPES.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== import_utils42.AST_NODE_TYPES.SpreadElement && isStaticValue3(el));
+    return init.elements.every((el) => el !== null && el.type !== import_utils42.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
   }
   if (init.type === import_utils42.AST_NODE_TYPES.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === import_utils42.AST_NODE_TYPES.Property && isStaticValue3(prop.value)
+      (prop) => prop.type === import_utils42.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
     );
   }
   return false;
@@ -2940,7 +2907,7 @@ var noMisleadingConstantCase = createRule38({
           if (!declarator.init) {
             return;
           }
-          if (!isStaticValue3(declarator.init)) {
+          if (!isStaticValue2(declarator.init)) {
             context.report({
               node: declarator.id,
               messageId: "dynamicScreamingCase",