eslint-plugin-hex-under 0.10.0 → 0.11.0

package/README.md

@@ -27,6 +27,8 @@ function add(a, b) {
   return a + b + 0x100;
 }
 
+let d = 0xaa_ffn;
+
 // This can be transformed to:
 const signal = 539;
 
@@ -35,6 +37,8 @@ let func = () => 2748;
 function add(a, b) {
   return a + b + 256;
 }
+
+let d = 43775;
 ```
 
 ## Integration
@@ -61,28 +65,6 @@ export default [
 ];
 ```
 
-#### Experimental BigInteger Support
-
-There is a similar rule to prove for BigInteger hexadecimal numbers. You can enable it similar to the `hex-under` rule. The default limit is 255.
-
-```js
-// eslint.config.js
-
-import eslintPluginHexUnder from "eslint-plugin-hex-under";
-
-export default = [
-  {
-    files: ["*.js"],
-    plugins: {
-      "hex-under": eslintPluginHexUnder,
-    },
-    rules: {
-      "hex-under/hex-under-bigint": "warn",
-    },
-  },
-];
-```
-
 ## Testing & Code Coverage
 
 This project uses **Vitest** as its test runner with comprehensive code coverage tracking. All tests are written using Vitest's modern testing framework and ESLint's RuleTester for validating rule behavior.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-hex-under",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "main": "src/eslint-plugin-hex-under.js",
   "scripts": {

package/src/eslint-plugin-hex-under.js

@@ -1,10 +1,8 @@
 import hexUnderRule from './rules/hex-under.js';
-import hexUnderBigintRule from './rules/hex-under-bigint.js';
 
 const plugin = {
   rules: {
     'hex-under': hexUnderRule,
-    'hex-under-bigint': hexUnderBigintRule,
   },
 };
 

package/src/rules/hex-under.js

@@ -1,7 +1,7 @@
 export default {
   meta: {
     type: 'suggestion',
-    version: '0.4.0',
+    version: '0.5.0',
     defaultOptions: [
       {
         limit: 255,
@@ -32,22 +32,33 @@ export default {
   },
 
   create(context) {
-    const { limit = 255 } = context.options[0] ?? {};
-    const HEX_REGEX = /^0[Xx][0-9a-fA-F_]+$/;
+    const [{ limit = 255 } = {}] = context.options;
+    const HEX_REGEX = /^0[xX][0-9a-fA-F_]+$/;
+    const HEX_REGEX_BIGINT = /^0[xX][0-9a-fA-F_]+n$/;
 
     return {
       Literal(node) {
-        if (typeof node.value !== 'number' || typeof node.raw !== 'string')
+        if (typeof node.value !== 'number' && typeof node.value !== 'bigint')
           return;
+        if (typeof node.raw !== 'string') return;
 
         const raw = node.raw;
+        const isHexBigInt = HEX_REGEX_BIGINT.test(raw);
+        const isHex = HEX_REGEX.test(raw);
 
-        if (!HEX_REGEX.test(raw)) return;
+        if (!isHex && !isHexBigInt) return;
 
-        const value = node.value;
-        if (Number.isNaN(value)) return;
-
-        if (value <= limit) return;
+        const normalized = raw.replace(/_/g, '').replace(/n$/, '');
+        let value = null;
+        if (isHexBigInt) {
+          value = BigInt(normalized);
+          if (value <= BigInt(limit)) return;
+        } else if (isHex) {
+          value = Number(normalized);
+          if (Number.isNaN(value) || value <= limit) return;
+        } else {
+          return;
+        }
 
         context.report({
           node,
@@ -58,7 +69,10 @@ export default {
             limit,
           },
           fix(fixer) {
-            return fixer.replaceText(node, String(value));
+            return fixer.replaceText(
+              node,
+              isHexBigInt ? `${String(BigInt(value))}n` : String(value),
+            );
           },
         });
       },

package/src/rules/hex-under-bigint.js

@@ -1,64 +0,0 @@
-export default {
-  meta: {
-    type: 'suggestion',
-    version: '0.1.0',
-    defaultOptions: [
-      {
-        limit: 255,
-      },
-    ],
-    docs: {
-      description:
-        'Ensures that a hexadecimal bigint does not exceed a specified value (default: 255).',
-      recommended: false,
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          limit: {
-            type: 'integer',
-            minimum: 0,
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      valueOverGeneralBigInt:
-        'Hex number {{ raw }} ({{ value }}) exceeds the limit of {{ limit }}.',
-    },
-  },
-  create(context) {
-    const { limit = 255 } = context.options[0] ?? {};
-    const HEX_REGEX = /^0[Xx][0-9a-fA-F_]+n$/;
-
-    return {
-      Literal(node) {
-        if (typeof node.raw !== 'string') return;
-
-        const raw = node.raw;
-
-        if (!HEX_REGEX.test(raw)) return;
-
-        const value = BigInt(node.raw.slice(0, -1).replace(/_/g, ''));
-
-        if (value <= BigInt(limit)) return;
-
-        context.report({
-          node,
-          messageId: 'valueOverGeneralBigInt',
-          data: {
-            raw,
-            value,
-            limit,
-          },
-          fix(fixer) {
-            return fixer.replaceText(node, `${String(BigInt(value))}n`);
-          },
-        });
-      },
-    };
-  },
-};