eslint-plugin-prefer-let 4.1.0 → 4.2.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # eslint-plugin-prefer-let
 
+## \[4.2.1]
+
+- [`fadad0b`](https://github.com/thefrontside/javascript/commit/fadad0b5cf786b3186d74a35d9933b5e8bea0e34) Ignore `export const` cases
+
+## \[4.2.0]
+
+- [`9066434`](https://github.com/thefrontside/javascript/commit/90664342144bce7d4a13812e82c155ba3d4ea7e0) Add `forceUpperCaseConst` option
+
 ## \[4.1.0]
 
 - [`6a5ba09`](https://github.com/thefrontside/javascript/commit/6a5ba096b531357d4c9ddd41fe158623cbebf601) Support ESLint v10

package/README.md

@@ -82,6 +82,38 @@ Then configure the rules you want to use under the rules section.
 }
 ```
 
+### Options
+
+#### `forceUpperCaseConst`
+
+When set to `true`, this option enforces `const` for top-level `UPPER_CASE` names (e.g. `PI`, `API_BASE_URL`)
+
+```json
+{
+    "rules": {
+        "prefer-let/prefer-let": [2, { "forceUpperCaseConst": true }]
+    }
+}
+```
+
+This makes the distinction between true constants and regular bindings explicit and machine-enforced.
+
+Good:
+
+```javascript
+const PI = 3.14;
+const API_BASE_URL = 'https://example.com';
+
+let config = loadConfig();
+```
+
+Bad:
+
+```javascript
+const config = loadConfig();  // not UPPER_CASE — use let
+let PI = 3.14;                // UPPER_CASE — use const
+```
+
 ### Possible Conflicts
 
 This plugin may conflict with other plugins or configs that set `eslint prefer-const`. You can configure the rules to avoid this:

package/lib/rules/prefer-let.js

@@ -17,12 +17,22 @@ module.exports = {
     },
     fixable: "code",  // or "code" or "whitespace"
     schema: [
-      // fill in your schema
+      {
+        type: "object",
+        properties: {
+          forceUpperCaseConst: {
+            type: "boolean"
+          }
+        },
+        additionalProperties: false
+      }
     ]
   },
 
   create: function(context) {
     let sourceCode = context.sourceCode ?? context.getSourceCode();
+    let options = context.options[0] || {};
+    let forceUpperCaseConst = options.forceUpperCaseConst || false;
 
     //----------------------------------------------------------------------
     // Helpers
@@ -51,6 +61,40 @@ module.exports = {
       return isGlobalScope(node) || isModuleScope(node) || isProgramScope(node);
     }
 
+    function isUpperCase(name) {
+      return /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/.test(name);
+    }
+
+    function getBindingNames(node) {
+      if (node.type === 'Identifier') {
+        return [node.name];
+      }
+      if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap(function(prop) {
+          return getBindingNames(prop.value || prop.argument);
+        });
+      }
+      if (node.type === 'ArrayPattern') {
+        return node.elements.filter(Boolean).flatMap(function(el) {
+          return getBindingNames(el);
+        });
+      }
+      if (node.type === 'RestElement') {
+        return getBindingNames(node.argument);
+      }
+      if (node.type === 'AssignmentPattern') {
+        return getBindingNames(node.left);
+      }
+      return [];
+    }
+
+    function allDeclaratorsUpperCase(node) {
+      return node.declarations.every(function(decl) {
+        let names = getBindingNames(decl.id);
+        return names.length > 0 && names.every(isUpperCase);
+      });
+    }
+
     function isInAmbientContext(node) {
       let current = node.parent;
       while (current) {
@@ -76,14 +120,37 @@ module.exports = {
             message: 'prefer `let` over `var` to declare value bindings',
             node
           });
-        } else if (node.kind === 'const' && !isTopLevelScope(node)) {
-          let constToken = sourceCode.getFirstToken(node);
-
+        } else if (node.kind === 'const') {
+          if (isTopLevelScope(node)) {
+            if (forceUpperCaseConst && !allDeclaratorsUpperCase(node)) {
+              let constToken = sourceCode.getFirstToken(node);
+              context.report({
+                message: '`const` declaration for non-constant names at top-level scope. Use `let` or rename to UPPER_CASE',
+                node,
+                fix: function(fixer) {
+                  return fixer.replaceText(constToken, 'let');
+                }
+              });
+            }
+          } else if (node.parent && node.parent.type === 'ExportNamedDeclaration') {
+            // ignore `export const` cases
+          } else {
+            let constToken = sourceCode.getFirstToken(node);
+            context.report({
+              message: '`const` declaration outside top-level scope',
+              node,
+              fix: function(fixer) {
+                return fixer.replaceText(constToken, 'let');
+              }
+            });
+          }
+        } else if (node.kind === 'let' && forceUpperCaseConst && isTopLevelScope(node) && allDeclaratorsUpperCase(node)) {
+          let letToken = sourceCode.getFirstToken(node);
           context.report({
-            message: '`const` declaration outside top-level scope',
+            message: 'use `const` for constant names (UPPER_CASE) at top-level scope',
             node,
             fix: function(fixer) {
-              return fixer.replaceText(constToken, 'let');
+              return fixer.replaceText(letToken, 'const');
             }
           });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-prefer-let",
-  "version": "4.1.0",
+  "version": "4.2.1",
   "description": "Rule to prefer using `let` to bind names to values",
   "repository": {
     "type": "git",