eslint-plugin-hex-under 0.12.3 → 1.0.0

package/README.md

@@ -18,6 +18,13 @@ function add(a, b) {
   return a + b + 0x1f;
 }
 
+const binary = 0b1111_1111;
+
+const octal = 0o377;
+
+// valid with { limit: 255, skipBigInt: true }
+const mask = 0xdead_beefn;
+
 // invalid with { limit: 255 }
 const signal = 0x21b;
 
@@ -29,6 +36,10 @@ function add(a, b) {
 
 let d = 0xaa_ffn;
 
+const binary = 0b1_0000_0000;
+
+const octal = 0o400;
+
 // This can be transformed to:
 const signal = 539;
 
@@ -39,6 +50,10 @@ function add(a, b) {
 }
 
 let d = 43775;
+
+const binary = 256;
+
+const octal = 256;
 ```
 
 ## Integration
@@ -59,7 +74,9 @@ export default [
       'hex-under': eslintPluginHexUnder,
     },
     rules: {
-      'hex-under/hex-under': ['error', { limit: 255 }],
+      'hex-under/hex-under': ['error', { limit: 255, skipBigInt: false }],
+      'hex-under/octal-under': ['error', { limit: 511, skipBigInt: false }],
+      'hex-under/binary-under': ['error', { limit: 15, skipBigInt: false }],
     },
   },
 ];

package/package.json

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

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

@@ -1,8 +1,12 @@
+import binaryUnder from './rules/binary-under.js';
 import hexUnderRule from './rules/hex-under.js';
+import octalUnder from './rules/octal-under.js';
 
 const plugin = {
   rules: {
     'hex-under': hexUnderRule,
+    'octal-under': octalUnder,
+    'binary-under': binaryUnder,
   },
 };
 

package/src/rules/binary-under.js

@@ -0,0 +1,71 @@
+const BINARY_REGEX = /^0[bB][01_]+$/;
+const BINARY_REGEX_BIGINT = /^0[bB][01_]+n$/;
+
+export default {
+  meta: {
+    version: '0.1.0',
+    type: 'suggestion',
+    docs: {
+      description: 'Ensures binary numbers do not exceed a limit.',
+      recommended: false,
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          limit: { type: 'integer', minimum: 0 },
+          skipBigInt: { type: 'boolean' },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      valueOver:
+        'Binary number {{ raw }} ({{ value }}) exceeds the limit of {{ limit }}.',
+    },
+  },
+
+  create(context) {
+    const [{ limit = 15, skipBigInt = false } = {}] = context.options;
+
+    return {
+      'Literal[raw=/^0[bB][01_]+n?$/]'(node) {
+        const raw = node.raw;
+        const isBigInt = BINARY_REGEX_BIGINT.test(raw);
+        const isBinary = BINARY_REGEX.test(raw);
+
+        if (skipBigInt && isBigInt) return;
+
+        const normalized = raw.replace(/_/g, '').replace(/n$/, '');
+        let value = null;
+
+        if (isBigInt) {
+          value = BigInt(normalized);
+          if (value <= BigInt(limit)) return;
+        }
+
+        if (isBinary) {
+          value = parseInt(normalized.slice(2), 2);
+          if (Number.isNaN(value) || value <= limit) return;
+        }
+
+        context.report({
+          node,
+          messageId: 'valueOver',
+          data: {
+            raw: raw,
+            value: value,
+            limit: limit,
+          },
+          fix(fixer) {
+            return fixer.replaceText(
+              node,
+              isBigInt ? `${String(value)}n` : String(value),
+            );
+          },
+        });
+      },
+    };
+  },
+};

package/src/rules/octal-under.js

@@ -0,0 +1,76 @@
+const OCTAL_REGEX = /^0[oO]?[0-7_]+$/;
+const OCTAL_REGEX_BIGINT = /^0[oO]?[0-7_]+n$/;
+
+export default {
+  meta: {
+    version: '0.1.0',
+    type: 'suggestion',
+    docs: {
+      description: 'Ensures octal numbers do not exceed a limit.',
+      recommended: false,
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          limit: { type: 'integer', minimum: 0 },
+          skipBigInt: { type: 'boolean' },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      valueOver:
+        'Octal number {{ raw }} ({{ value }}) exceeds the limit of {{ limit }}.',
+    },
+  },
+
+  create(context) {
+    const [{ limit = 511, skipBigInt = false } = {}] = context.options;
+
+    return {
+      'Literal[raw=/^0[oO]?[0-7_]+n?$/]'(node) {
+        const raw = node.raw;
+
+        if (
+          raw.startsWith('0') &&
+          !raw.startsWith('0o') &&
+          !raw.startsWith('0O')
+        ) {
+          return;
+        }
+
+        const isBigInt = OCTAL_REGEX_BIGINT.test(raw);
+        const isOctal = OCTAL_REGEX.test(raw);
+
+        if (skipBigInt && isBigInt) return;
+
+        const normalized = raw.replace(/_/g, '').replace(/n$/, '');
+        let value = null;
+
+        if (isBigInt) {
+          value = BigInt(normalized);
+          if (value <= BigInt(limit)) return;
+        }
+
+        if (isOctal) {
+          value = parseInt(normalized.slice(2), 8);
+          if (Number.isNaN(value) || value <= limit) return;
+        }
+
+        context.report({
+          node,
+          messageId: 'valueOver',
+          data: { raw, value, limit },
+          fix(fixer) {
+            return fixer.replaceText(
+              node,
+              isBigInt ? `${String(value)}n` : String(value),
+            );
+          },
+        });
+      },
+    };
+  },
+};