@blumintinc/eslint-plugin-blumint 1.20.148 → 1.20.149

package/lib/index.js

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

package/lib/rules/no-array-length-in-deps.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const hungarianNaming_1 = require("../utils/hungarianNaming");
 const importInsertion_1 = require("../utils/importInsertion");
 // React hooks to check
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
@@ -62,10 +63,45 @@ function getLastPropertyName(expr) {
     }
     return null;
 }
+/**
+ * The name used when the base contributes nothing spellable. Free of any type
+ * marker by construction, and the concept the memo actually stands for — the
+ * hash of the dependency's CONTENT, which is what depending on `.length`
+ * failed to track.
+ */
+const BASE_FREE_HASH_NAME = 'contentHash';
+function capitalize(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/**
+ * Names for the memo binding, in descending order of how much of the base they
+ * keep. `no-hungarian` ships as an error and is NOT fixable, so a name it
+ * rejects turns this fixer's work into a manual rename in a file that was clean
+ * beforehand (#1997) — every candidate is therefore checked against the same
+ * predicate that rule applies, and the first acceptable one wins.
+ *
+ * Which candidate that is follows from what `no-hungarian` rejects:
+ *
+ * - `<base>Hash` reads as the domain concept for almost every base and is the
+ *   preferred spelling.
+ * - A single-letter `b`/`i` base makes `bHash`/`iHash` look like a Hungarian
+ *   type prefix (b=boolean, i=integer) glued to a capital. `hashOf<Base>` says
+ *   the same thing with the base out of the leading position.
+ * - A base that IS a type word or its abbreviation (`obj`, `arr`, `str`,
+ *   `array`, `number`, ...) taints every name that carries it as a segment, so
+ *   no base-preserving candidate can succeed. Dropping the type-coded base is
+ *   exactly the rename `no-hungarian` asks for.
+ */
+function baseDerivedNames(base) {
+    return [`${base}Hash`, `hashOf${capitalize(base)}`];
+}
 function generateUniqueName(base, taken) {
-    const candidate = `${base}Hash`;
+    const candidate = baseDerivedNames(base).find((name) => !(0, hungarianNaming_1.encodesTypeMarker)(name)) ??
+        BASE_FREE_HASH_NAME;
     if (!taken.has(candidate))
         return candidate;
+    // A numeric suffix disambiguates without reopening the naming question: it
+    // adds no word boundary, so it cannot turn an accepted name into a marker.
     let i = 2;
     while (taken.has(`${candidate}${i}`)) {
         i++;

package/lib/utils/hungarianNaming.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Mirrors the type-marker predicate the shipped `no-hungarian` rule applies to
+ * a declaration name, so a fixer can refuse to SYNTHESISE a name that rule
+ * rejects. `no-hungarian` is not fixable, so a generated identifier it flags
+ * converts machine-resolvable work into a manual rename inside a file that was
+ * clean before `--fix` ran (#1997).
+ *
+ * Scope is the shape a fixer emits: an alphanumeric camelCase/PascalCase
+ * identifier. `no-hungarian`'s SCREAMING_SNAKE_CASE branch and its
+ * compound-noun / descriptive-suffix / <entity>Number / <domain>Symbol
+ * carve-outs are deliberately absent. Every one of them can only turn a
+ * rejection into an acceptance, and each is keyed on a trailing word a
+ * generated name does not carry, so their absence is unreachable for such a
+ * name and, if ever reached, costs the caller its next candidate rather than
+ * reintroducing the defect. `no-array-length-in-deps.test.ts` pins agreement
+ * with the real rule over the corpus of names its fixer can emit, so a change
+ * to either predicate surfaces there.
+ */
+/**
+ * Whether `no-hungarian` reads `name` as encoding its own type.
+ */
+export declare function encodesTypeMarker(name: string): boolean;

package/lib/utils/hungarianNaming.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Mirrors the type-marker predicate the shipped `no-hungarian` rule applies to
+ * a declaration name, so a fixer can refuse to SYNTHESISE a name that rule
+ * rejects. `no-hungarian` is not fixable, so a generated identifier it flags
+ * converts machine-resolvable work into a manual rename inside a file that was
+ * clean before `--fix` ran (#1997).
+ *
+ * Scope is the shape a fixer emits: an alphanumeric camelCase/PascalCase
+ * identifier. `no-hungarian`'s SCREAMING_SNAKE_CASE branch and its
+ * compound-noun / descriptive-suffix / <entity>Number / <domain>Symbol
+ * carve-outs are deliberately absent. Every one of them can only turn a
+ * rejection into an acceptance, and each is keyed on a trailing word a
+ * generated name does not carry, so their absence is unreachable for such a
+ * name and, if ever reached, costs the caller its next candidate rather than
+ * reintroducing the defect. `no-array-length-in-deps.test.ts` pins agreement
+ * with the real rule over the corpus of names its fixer can emit, so a change
+ * to either predicate surfaces there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodesTypeMarker = void 0;
+// Abbreviation type markers. No English word is spelled this way, so their
+// presence as a whole camelCase segment is unambiguously a type tag.
+const ABBREVIATION_MARKERS = ['str', 'num', 'int', 'bool', 'arr', 'obj'];
+const COMMON_TYPES = [
+    'String',
+    'Number',
+    'Boolean',
+    'Array',
+    'Object',
+    'RegExp',
+    'Promise',
+    'Symbol',
+    'BigInt',
+];
+const TYPE_MARKERS = [
+    ...ABBREVIATION_MARKERS,
+    'array',
+    ...COMMON_TYPES,
+    'Class',
+    'Interface',
+    'Enum',
+];
+const ABBREVIATION_MARKER_SET = new Set(ABBREVIATION_MARKERS);
+const FULL_TYPE_WORDS = new Set(COMMON_TYPES.map((word) => word.toLowerCase()));
+// Single-letter Hungarian type prefixes (b=boolean, i=integer/index), matched
+// only as a strict camelCase prefix. This is the arm that rejects `bHash`.
+const SINGLE_LETTER_PREFIXES = new Set(['b', 'i']);
+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) ?? [];
+}
+// A built-in type word carrying an internal capital (BigInt) splits into parts
+// whose tail collides with an abbreviation marker (Int/int), so the parts are
+// re-merged into one atomic segment before segment matching.
+const MULTI_CAPITAL_TYPE_WORD_PARTS = COMMON_TYPES.map(splitCamelSegmentsRaw).filter((parts) => parts.length > 1);
+function mergeMultiCapitalTypeWords(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;
+}
+function splitCamelSegments(name) {
+    return mergeMultiCapitalTypeWords(splitCamelSegmentsRaw(name));
+}
+function isPascalCaseName(name) {
+    return /^[A-Z]/.test(name) && name !== name.toUpperCase();
+}
+// A PascalCase name whose type word qualifies a DIFFERENT head noun names a
+// concept or relation (StringToNumber, NumberAmountEditor), not the value's own
+// runtime type.
+function isSemanticTypeConcept(name) {
+    const segments = splitCamelSegments(name);
+    if (segments.length < 2) {
+        return false;
+    }
+    const hasTypeWord = segments.some((segment) => FULL_TYPE_WORDS.has(segment.toLowerCase()));
+    if (!hasTypeWord) {
+        return false;
+    }
+    return segments.some((segment) => !FULL_TYPE_WORDS.has(segment.toLowerCase()));
+}
+/**
+ * Whether `no-hungarian` reads `name` as encoding its own type.
+ */
+function encodesTypeMarker(name) {
+    if (isPascalCaseName(name) && isSemanticTypeConcept(name)) {
+        return false;
+    }
+    if (name.length > 1 &&
+        SINGLE_LETTER_PREFIXES.has(name[0]) &&
+        /[A-Z]/.test(name[1])) {
+        return true;
+    }
+    const normalizedName = name.toLowerCase();
+    return TYPE_MARKERS.some((marker) => {
+        const normalizedMarker = marker.toLowerCase();
+        if (normalizedName === normalizedMarker) {
+            return false;
+        }
+        // An abbreviation marker is a type tag only as a whole segment: "int"
+        // inside "Mint" or "point" is a word fragment, not a tag.
+        if (ABBREVIATION_MARKER_SET.has(normalizedMarker)) {
+            return splitCamelSegments(name).some((segment) => segment.toLowerCase() === normalizedMarker);
+        }
+        // A full type word tags the value's type only at a word boundary in
+        // leading or trailing position; a middle segment qualifies a domain concept.
+        if (normalizedName.startsWith(normalizedMarker) &&
+            normalizedName.length > normalizedMarker.length &&
+            /[A-Z0-9]/.test(name[normalizedMarker.length])) {
+            return true;
+        }
+        return (normalizedName.endsWith(normalizedMarker) &&
+            normalizedName.length > normalizedMarker.length &&
+            (/[A-Z0-9]/.test(name[name.length - normalizedMarker.length - 1]) ||
+                /[A-Z]/.test(name[name.length - normalizedMarker.length])));
+    });
+}
+exports.encodesTypeMarker = encodesTypeMarker;
+//# sourceMappingURL=hungarianNaming.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.149",
+    "date": "2026-08-13T16:22:27.196Z",
+    "rules": [
+      {
+        "name": "no-array-length-in-deps",
+        "changeType": "fix",
+        "issues": [
+          1997
+        ],
+        "summary": "emit a hash name no-hungarian accepts (closes #1997)"
+      }
+    ]
+  },
   {
     "version": "1.20.148",
     "date": "2026-08-13T13:06:17.038Z",