eslint-plugin-hex-under 0.8.3 → 0.9.0

package/README.md

@@ -46,16 +46,16 @@ npm install --save-dev eslint-plugin-hex-under
 ```js
 // eslint.config.js
 
-import eslintPluginHexUnder from "eslint-plugin-hex-under";
+import eslintPluginHexUnder from 'eslint-plugin-hex-under';
 
 export default [
   {
-    files: ["*.js"],
+    files: ['*.js'],
     plugins: {
-      "hex-under": eslintPluginHexUnder,
+      'hex-under': eslintPluginHexUnder,
     },
     rules: {
-      "hex-under/hex-under": ["error", { limit: 255 }],
+      'hex-under/hex-under': ['error', { limit: 255 }],
     },
   },
 ];

package/package.json

@@ -1,25 +1,32 @@
 {
   "name": "eslint-plugin-hex-under",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "type": "module",
   "main": "src/eslint-plugin-hex-under.js",
   "scripts": {
+    "coverage": "vitest run --coverage",
     "lint": "prettier . --check && eslint .",
     "test": "vitest run",
     "test:all": "npm run test && npm run test:bats",
-    "test:bats": "bats test/*.bats",
-    "test:watch": "vitest",
-    "coverage": "vitest run --coverage"
+    "test:bats": "bats --print-output-on-failure test/*.bats",
+    "test:watch": "vitest"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/0xflotus/eslint-plugin-hex-under.git"
+  "repository": "github:0xflotus/eslint-plugin-hex-under",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "lint",
+    "hex",
+    "static-analysis"
+  ],
+  "engines": {
+    "node": ">=22"
   },
-  "keywords": [],
   "author": "0xflotus",
   "license": "MIT",
   "description": "This ESLint rule proves that hex numbers are less than a specified value.",
   "devDependencies": {
+    "@eslint/js": "10.0.1",
     "@vitest/coverage-v8": "4.1.0",
     "bats": "1.13.0",
     "eslint": "10.0.3",

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

@@ -1,10 +1,10 @@
-import hexUnderRule from "./rules/hex-under.js";
-import hexUnderBigintRule from "./rules/hex-under-bigint.js";
+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,
+    'hex-under': hexUnderRule,
+    'hex-under-bigint': hexUnderBigintRule,
   },
 };
 

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

@@ -1,7 +1,7 @@
 export default {
   meta: {
-    type: "suggestion",
-    version: "0.0.2",
+    type: 'suggestion',
+    version: '0.0.2',
     defaultOptions: [
       {
         limit: 255,
@@ -9,15 +9,15 @@ export default {
     ],
     docs: {
       description:
-        "Proves that a hexadecimal bigint must be less than a specified value. Default is 255.",
+        'Proves that a hexadecimal bigint must be less than a specified value. Default is 255.',
     },
-    fixable: "code",
+    fixable: 'code',
     schema: [
       {
-        type: "object",
+        type: 'object',
         properties: {
           limit: {
-            type: "integer",
+            type: 'integer',
             minimum: 0,
           },
         },
@@ -26,22 +26,22 @@ export default {
     ],
     messages: {
       valueOverGeneralBigInt:
-        "This bigint must be less than or equal {{ limit }}. {{ overValue }} ({{ over255Raw }}) is greater than {{ limit }}.",
+        'This bigint must be less than or equal {{ limit }}. {{ overValue }} ({{ over255Raw }}) is greater than {{ limit }}.',
     },
   },
   create(context) {
     const options = context.options[0] || {};
-    const limit = typeof options.limit === "number" ? options.limit : 255;
+    const limit = typeof options.limit === 'number' ? options.limit : 255;
 
     return {
       onCodePathEnd: function (_codePath, node) {
         const tokens =
           node.tokens?.filter(
             (token) =>
-              ["Numeric", "Identifier"].includes(token.type) &&
-              typeof token.value === "string" &&
-              token.value.startsWith("0x") &&
-              token.value.endsWith("n"),
+              ['Numeric', 'Identifier'].includes(token.type) &&
+              typeof token.value === 'string' &&
+              token.value.startsWith('0x') &&
+              token.value.endsWith('n'),
           ) || [];
 
         for (const token of tokens) {
@@ -53,14 +53,14 @@ export default {
             if (value > limitBigInt) {
               context.report({
                 node: token,
-                messageId: "valueOverGeneralBigInt",
+                messageId: 'valueOverGeneralBigInt',
                 data: {
                   limit: limit,
                   over255Raw: token.value,
                   overValue: value.toString(),
                 },
                 fix(fixer) {
-                  return fixer.replaceText(token, value.toString() + "n");
+                  return fixer.replaceText(token, value.toString() + 'n');
                 },
               });
             }

package/src/rules/hex-under.js

@@ -1,7 +1,7 @@
 export default {
   meta: {
-    type: "suggestion",
-    version: "0.3.0",
+    type: 'suggestion',
+    version: '0.4.0',
     defaultOptions: [
       {
         limit: 255,
@@ -9,15 +9,16 @@ export default {
     ],
     docs: {
       description:
-        "Proves that a hexadecimal number must be less than a specified value. Default is 255.",
+        'Ensures that a hexadecimal number does not exceed a specified value (default: 255).',
+      recommended: false,
     },
-    fixable: "code",
+    fixable: 'code',
     schema: [
       {
-        type: "object",
+        type: 'object',
         properties: {
           limit: {
-            type: "integer",
+            type: 'integer',
             minimum: 0,
           },
         },
@@ -26,50 +27,40 @@ export default {
     ],
     messages: {
       valueOverGeneral:
-        "This number must be less than or equal {{ limit }}. {{ overValue }} ({{ over255Raw }}) is greater than {{ limit }}.",
+        'Hex number {{ raw }} ({{ value }}) exceeds the limit of {{ limit }}.',
     },
   },
+
   create(context) {
-    const options = context.options[0] || {};
-    const limit = typeof options.limit === "number" ? options.limit : 255;
+    const { limit = 255 } = context.options[0] ?? {};
+    const HEX_REGEX = /^0[Xx][0-9a-fA-F_]+$/;
 
     return {
-      onCodePathEnd: function (_codePath, node) {
-        const tokens =
-          node.tokens?.filter(
-            (token) =>
-              ["Numeric", "Identifier"].includes(token.type) &&
-              typeof token.value === "string" &&
-              token.value.startsWith("0x") &&
-              !token.value.endsWith("n"),
-          ) || [];
+      Literal(node) {
+        if (typeof node.value !== 'number' || typeof node.raw !== 'string')
+          return;
+
+        const raw = node.raw;
+
+        if (!HEX_REGEX.test(raw)) return;
 
-        for (const token of tokens) {
-          try {
-            const value = parseInt(token.value, 16);
+        const value = node.value;
+        if (Number.isNaN(value)) return;
 
-            if (isNaN(value)) {
-              continue;
-            }
+        if (value <= limit) return;
 
-            if (value > limit) {
-              context.report({
-                node: token,
-                messageId: "valueOverGeneral",
-                data: {
-                  limit: limit,
-                  over255Raw: token.value,
-                  overValue: value,
-                },
-                fix(fixer) {
-                  return fixer.replaceText(token, String(value));
-                },
-              });
-            }
-          } catch {
-            continue;
-          }
-        }
+        context.report({
+          node,
+          messageId: 'valueOverGeneral',
+          data: {
+            raw,
+            value,
+            limit,
+          },
+          fix(fixer) {
+            return fixer.replaceText(node, String(value));
+          },
+        });
       },
     };
   },