@blumintinc/eslint-plugin-blumint 1.19.14 → 1.19.16

package/lib/index.js

@@ -222,7 +222,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.19.14',
+        version: '1.19.16',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/no-hungarian.js

@@ -256,10 +256,48 @@ const BUILT_IN_METHODS = new Set([
     'catch',
     'finally',
 ]);
+// The camelCase/PascalCase splitter's core pattern. Kept separate from
+// splitCamelSegments so precomputed constants (below) can fragment known type
+// words without recursing through the merge step.
+const CAMEL_SEGMENT_REGEX = /[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g;
+function splitCamelSegmentsRaw(name) {
+    return name.match(CAMEL_SEGMENT_REGEX) ?? [];
+}
+// COMMON_TYPES words containing an internal capital — only `BigInt` today — are
+// fragmented by the splitter into parts (["Big","Int"]) where a fragment ("Int")
+// collides with an abbreviation marker ("int"), so ANY identifier containing
+// BigInt would spuriously match that marker regardless of position (#1317).
+// Precompute those fragment sequences so splitCamelSegments can re-merge them
+// into a single atomic segment, ensuring a built-in type word is never mistaken
+// for a Hungarian abbreviation tag.
+const MULTI_CAPITAL_TYPE_WORD_PARTS = COMMON_TYPES.map(splitCamelSegmentsRaw).filter((parts) => parts.length > 1);
+// Re-merge any consecutive segments that reconstitute a multi-capital built-in
+// type word (Big + Int -> BigInt). Case-insensitive so lower/upper camelCase
+// variants collapse identically.
+function mergeMultiCapitalTypeWords(segments) {
+    if (MULTI_CAPITAL_TYPE_WORD_PARTS.length === 0) {
+        return segments;
+    }
+    const merged = [];
+    let index = 0;
+    while (index < segments.length) {
+        const match = MULTI_CAPITAL_TYPE_WORD_PARTS.find((parts) => parts.every((part, offset) => segments[index + offset]?.toLowerCase() === part.toLowerCase()));
+        if (match) {
+            merged.push(segments.slice(index, index + match.length).join(''));
+            index += match.length;
+        }
+        else {
+            merged.push(segments[index]);
+            index += 1;
+        }
+    }
+    return merged;
+}
 // Split a PascalCase/camelCase identifier into its word segments
 // (e.g. "StringToNumber" -> ["String","To","Number"], "FuncKeys" -> ["Func","Keys"]).
+// Multi-capital built-in type words (BigInt) are kept as one atomic segment.
 function splitCamelSegments(name) {
-    return name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g) ?? [];
+    return mergeMultiCapitalTypeWords(splitCamelSegmentsRaw(name));
 }
 // A TYPE name (alias/interface/class) is exempt from a full-type-word marker when
 // that marker is one clean PascalCase segment among OTHER descriptive segments —
@@ -280,6 +318,13 @@ function isSemanticTypeConcept(typeName) {
     // concept (e.g. Extract+Number) rather than bare type tags glued together.
     return segments.some((segment) => !FULL_TYPE_WORDS.has(segment.toLowerCase()));
 }
+// A PascalCase declaration name (leading capital, at least one lowercase letter):
+// a component, class, or type identifier. Distinguished from SCREAMING_SNAKE_CASE
+// constants (all caps) and lowercase-initial variables, which are handled on their
+// own code paths.
+function isPascalCaseName(name) {
+    return /^[A-Z]/.test(name) && name !== name.toUpperCase();
+}
 // Is `name` a domain compound of the form <entity>Number, where the word directly
 // before the trailing "Number" is a known domain-entity noun (issueNumber,
 // lineNumber, roundNumber, versionNumber)? Only the LAST head segment is
@@ -336,7 +381,17 @@ exports.noHungarian = (0, createRule_1.createRule)({
             // Type names whose type-word denotes a concept/relation (StringToNumber,
             // CapitalizedString, FuncKeys, PromiseOrValue) are not Hungarian — the word
             // is part of the type's meaning, like the allowed compound noun PhoneNumber.
-            if (isTypeName && isSemanticTypeConcept(variableName)) {
+            //
+            // Extended to any PascalCase declaration (components, classes, functions):
+            // when a built-in type word qualifies a DIFFERENT head noun the value is a
+            // component / props type, never a number/bigint (NumberAmountEditor,
+            // BigIntAmountEditorProps) — the leading-position analog of the
+            // DOMAIN_NUMBER_HEAD_NOUNS suffix carve-out, mirroring Intl.NumberFormat /
+            // StringBuilder / NumberFormatter. Keyed on PascalCase because a
+            // lowercase-initial variable (numberCount, stringValue) DOES encode its own
+            // value's type and must keep firing (#1317).
+            if ((isTypeName || isPascalCaseName(variableName)) &&
+                isSemanticTypeConcept(variableName)) {
                 return false;
             }
             // Single-letter Hungarian prefixes (bIsActive, iCount): a lone b/i directly

package/lib/rules/prefer-getter-over-parameterless-method.js

@@ -661,6 +661,15 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                         ? (suggestedNameCounts.get(classBody)?.get(scopeKey) ?? 0) > 1
                         : false;
                     const isAsync = node.value.async;
+                    // Only `private` methods are safe to autofix. A public / protected /
+                    // unspecified-accessibility method is API surface whose call sites of
+                    // the form `instance.method()` may live in other files this
+                    // single-file rule never sees. Converting such a method to a getter
+                    // silently breaks every external caller (the call would invoke the
+                    // getter's return value), so the fix must be withheld for anything
+                    // not demonstrably private. The report (nudge) is still emitted.
+                    const isPrivate = node.accessibility === 'private' ||
+                        node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier;
                     context.report({
                         node: node.key,
                         messageId: sideEffectReason
@@ -671,7 +680,8 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                             suggestedName,
                             reason: sideEffectReason ?? 'it returns a value',
                         },
-                        fix: sideEffectReason ||
+                        fix: !isPrivate ||
+                            sideEffectReason ||
                             isAsync ||
                             !leftParen ||
                             !rightParen ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.19.14",
+  "version": "1.19.16",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.16",
+    "date": "2026-07-18T06:29:03.568Z",
+    "rules": [
+      {
+        "name": "prefer-getter-over-parameterless-method",
+        "changeType": "fix",
+        "issues": [
+          1318
+        ],
+        "summary": "withhold autofix for non-private methods (closes #1318)"
+      }
+    ]
+  },
+  {
+    "version": "1.19.15",
+    "date": "2026-07-17T23:29:51.136Z",
+    "rules": [
+      {
+        "name": "no-hungarian",
+        "changeType": "fix",
+        "issues": [
+          1317
+        ],
+        "summary": "exempt PascalCase domain-qualifier names using built-in type words (closes #1317)"
+      }
+    ]
+  },
   {
     "version": "1.19.14",
     "date": "2026-07-17T21:35:22.880Z",