@blumintinc/eslint-plugin-blumint 1.20.100 → 1.20.102

package/lib/index.js

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

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -4,7 +4,60 @@ exports.enforceCentralizedMockFirestore = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const importInsertion_1 = require("../utils/importInsertion");
-const MOCK_FIRESTORE_PATH = '../../../../../__test-utils__/mockFirestore';
+/**
+ * The centralized module's identity: the path segments that name it, without
+ * the relative prefix a specifier needs to reach it. Keeping the identity
+ * separate from the specifier is what makes the self-file guard below correct
+ * no matter what prefix the fixer emits — the emitted depth is a hardcoded
+ * guess (Issue #1387) and a guard keyed on it would exempt the wrong files.
+ */
+const MOCK_FIRESTORE_MODULE = '__test-utils__/mockFirestore';
+const MOCK_FIRESTORE_PATH = `../../../../../${MOCK_FIRESTORE_MODULE}`;
+const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx)$/;
+/**
+ * The module every other file is told to import from is the one module that
+ * must define `mockFirestore` locally: rewriting it produces an import of
+ * itself, so the canonical implementation is deleted and the module imports a
+ * name it no longer defines.
+ *
+ * The linted path is matched by suffix because it reaches the rule in whatever
+ * form the caller used — absolute (`/repo/src/__test-utils__/mockFirestore.ts`)
+ * or project-relative (`__test-utils__/mockFirestore.ts`). The suffix has to
+ * land on a path-segment boundary, otherwise `not__test-utils__/mockFirestore`
+ * — an unrelated module — would be exempted too.
+ */
+const isCentralizedMockModule = (filename) => {
+    const normalized = filename.replace(/\\/g, '/').replace(SOURCE_EXTENSION, '');
+    if (!normalized.endsWith(MOCK_FIRESTORE_MODULE)) {
+        return false;
+    }
+    const suffixStart = normalized.length - MOCK_FIRESTORE_MODULE.length;
+    return suffixStart === 0 || normalized[suffixStart - 1] === '/';
+};
+/**
+ * Reports whether a flagged declaration sits on the module's export surface,
+ * either as `export const mockFirestore = …` or as one binding of an exported
+ * multi-declarator `const`.
+ *
+ * An exported name is a cross-file contract whose importers a single-file fixer
+ * cannot reach: retiring the declaration drops the name from the surface and
+ * every importer fails to resolve it. The hazard lives entirely in those other
+ * files, so it does not depend on whether the declaring file also uses the name
+ * — a mock module with no local use sites is the most exposed shape, not the
+ * safest. `global-const-style` and `renameFixes` withhold their fixes on the
+ * same grounds.
+ *
+ * Only `ExportNamedDeclaration` can front a flagged node: `export default`
+ * takes an expression, never a `const`, and a class property — the other shape
+ * this rule flags — belongs to its class rather than to the module, so
+ * `export default class { mockFirestore = … }` exports nothing by that name.
+ */
+function isExportedDeclaration(node) {
+    const statement = node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration
+        ? node.parent
+        : node;
+    return statement.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration;
+}
 function isHorizontalWhitespace(character) {
     return character === ' ' || character === '\t';
 }
@@ -58,16 +111,20 @@ const STATEMENT_CONTAINERS = new Set([
     utils_1.AST_NODE_TYPES.TSModuleBlock,
 ]);
 /**
- * Widens a declaration to the `export` that fronts it, whose keyword lives
- * outside the declaration's own range and would otherwise be stranded.
+ * The declaration when it stands as a statement of its own, and nothing
+ * otherwise.
+ *
+ * An `export const` is deliberately not widened to the `export` that fronts it:
+ * swallowing the keyword retires the name from the module's export surface, so
+ * such a declaration has no retirable statement at all and its enclosing
+ * `ExportNamedDeclaration` is absent from `STATEMENT_CONTAINERS` for that
+ * reason. `isExportedDeclaration` refuses the same shape ahead of this call and
+ * covers the multi-declarator form this branch never sees.
  */
 function retirableStatement(declaration) {
-    const statement = declaration.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration
-        ? declaration.parent
-        : declaration;
-    return statement.parent &&
-        STATEMENT_CONTAINERS.has(statement.parent.type)
-        ? statement
+    return declaration.parent &&
+        STATEMENT_CONTAINERS.has(declaration.parent.type)
+        ? declaration
         : undefined;
 }
 function retiredSpan(node) {
@@ -167,6 +224,20 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        // A processor hands the rule a virtual filename for an extracted code block;
+        // the physical path is the one that identifies the module on disk.
+        const filename = context.getPhysicalFilename
+            ? context.getPhysicalFilename()
+            : context.getFilename();
+        // The centralized module is exempt outright rather than reported without a
+        // fix: its local definition IS the canonical one this rule directs every
+        // other file to, so there is nothing for its author to do — the message's
+        // remedy, "import mockFirestore from the centralized test util", names the
+        // file it is reported in. `use-custom-memo`, `use-custom-router` and
+        // `use-custom-link` exempt their wrapper implementations the same way.
+        if (isCentralizedMockModule(filename)) {
+            return {};
+        }
         let hasCentralizedImport = false;
         const mockFirestoreNodes = new Set();
         const customMockFirestoreNames = new Set();
@@ -302,6 +373,13 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                             // them.
                             const removals = [];
                             for (const node of mockFirestoreNodes) {
+                                if (isExportedDeclaration(node)) {
+                                    // Retiring an exported declaration takes the name off the
+                                    // module's export surface, breaking importers this fixer
+                                    // cannot see. The report stands so the local mock is still
+                                    // surfaced; collapsing it is a cross-file edit a human owns.
+                                    return null;
+                                }
                                 const span = retiredSpan(node);
                                 if (!span) {
                                     // A declaration that cannot be excised cleanly gets no

package/lib/rules/enforce-identifiable-firestore-type.js

@@ -8,6 +8,14 @@ const utils_1 = require("@typescript-eslint/utils");
 const path_1 = __importDefault(require("path"));
 const createRule_1 = require("../utils/createRule");
 const TRANSPARENT_TYPE_NAMES = new Set(['Readonly', 'Resolve']);
+// A binding introduced by any of these declares a type whose shape lives in
+// another module. This rule is purely syntactic and reads a single file, so
+// such a type is opaque to it.
+const IMPORT_BINDING_NODE_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.ImportSpecifier,
+    utils_1.AST_NODE_TYPES.ImportDefaultSpecifier,
+    utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier,
+]);
 exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
     name: 'enforce-identifiable-firestore-type',
     meta: {
@@ -47,6 +55,10 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
         let matchingAliasNode = null;
         let matchingAliasInlineExported = false;
         let matchingAliasHasIdentifiable = false;
+        // Set when resolving the matching alias runs into a type that is declared
+        // in another module. Such a type is opaque to this single-file walk, so the
+        // absence of `Identifiable` is unproven rather than disproven.
+        let matchingAliasLeavesModule = false;
         const locallyExportedNames = new Set();
         return {
             Program() {
@@ -54,6 +66,7 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                 matchingAliasNode = null;
                 matchingAliasInlineExported = false;
                 matchingAliasHasIdentifiable = false;
+                matchingAliasLeavesModule = false;
                 locallyExportedNames.clear();
             },
             'Program:exit'(node) {
@@ -69,7 +82,13 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                         },
                     });
                 }
-                else if (!matchingAliasHasIdentifiable) {
+                else if (!matchingAliasHasIdentifiable &&
+                    !matchingAliasLeavesModule) {
+                    // A chain that leaves the module is unknowable here: the imported
+                    // type may well intersect `Identifiable`, and reporting would demand
+                    // a type-theoretically redundant `Identifiable &` to silence a claim
+                    // the rule cannot substantiate. Staying silent trades a false
+                    // positive for a false negative, which this repo prefers.
                     context.report({
                         node,
                         messageId: 'notExtendingIdentifiable',
@@ -95,6 +114,23 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                     matchingAliasNode = node;
                     matchingAliasInlineExported =
                         node.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration;
+                    // Raised by the resolution walk below whenever a referenced type name
+                    // resolves to an imported binding, i.e. the alias chain ran out of
+                    // this file. Scoped to this alias so an import that no chain ever
+                    // reaches — an unrelated `Timestamp`, or a type argument the walk
+                    // never descends into — grants no amnesty.
+                    let leavesModule = false;
+                    const isImportedBinding = (name) => {
+                        let scope = context.getScope();
+                        while (scope) {
+                            const variable = scope.variables.find((variableNode) => variableNode.name === name);
+                            if (variable) {
+                                return variable.defs.some((definition) => IMPORT_BINDING_NODE_TYPES.has(definition.node.type));
+                            }
+                            scope = scope.upper;
+                        }
+                        return false;
+                    };
                     const findTypeAliasAnnotation = (typeName) => {
                         let scope = context.getScope();
                         while (scope) {
@@ -108,11 +144,37 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                                     definition.node.typeAnnotation) {
                                     return definition.node.typeAnnotation;
                                 }
+                                // The name is bound, but only to something this file cannot
+                                // see through: an import. Record that the chain crossed the
+                                // module boundary so the caller distinguishes "proved no
+                                // Identifiable" from "could not look". A name with no binding
+                                // at all (a lib global such as `Readonly` or `Map`) is left
+                                // alone: those are known not to be Identifiable-bearing
+                                // aliases, and treating them as unknown would silence the
+                                // rule almost everywhere.
+                                if (variable.defs.some((definition) => IMPORT_BINDING_NODE_TYPES.has(definition.node.type))) {
+                                    leavesModule = true;
+                                }
                             }
                             scope = scope.upper;
                         }
                         return null;
                     };
+                    // `Types.Team` from `import * as Types from '../Team'` names a type
+                    // in another module just as `Team` from a named import does, but it
+                    // carries a TSQualifiedName that the walks below never resolve. The
+                    // leftmost identifier is the namespace binding, so it answers the
+                    // same question: did the chain leave this file?
+                    const noteQualifiedNamespaceImport = (qualifiedName) => {
+                        let left = qualifiedName.left;
+                        while (left.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                            left = left.left;
+                        }
+                        if (left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            isImportedBinding(left.name)) {
+                            leavesModule = true;
+                        }
+                    };
                     const isParenthesizedType = (node) => node?.type === 'TSParenthesizedType';
                     const isReadonlyTypeOperator = (node) => node?.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
                         node.operator === 'readonly';
@@ -229,12 +291,18 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                             const aliasAnnotation = findTypeAliasAnnotation(typeName);
                             return checkType(aliasAnnotation, visitedTypes);
                         }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                            noteQualifiedNamespaceImport(resolvedType.typeName);
+                            return false;
+                        }
                         if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
                             return resolvedType.types.some((part) => checkType(part, new Set(visitedTypes)));
                         }
                         return false;
                     };
                     matchingAliasHasIdentifiable = checkType(node.typeAnnotation);
+                    matchingAliasLeavesModule = leavesModule;
                 }
             },
         };

package/lib/rules/ensure-pointer-events-none.js

@@ -25,8 +25,19 @@ function isPointerEventsProperty(propertyName) {
 }
 /**
  * The inset offsets that position a pseudo-element relative to its origin box.
+ * The `inset` shorthand and its logical-property spellings carry the same sign
+ * semantics as the longhands, so an overlay must not change verdict on spelling
+ * alone.
  */
-const INSET_PROPERTIES = new Set(['top', 'right', 'bottom', 'left']);
+const INSET_PROPERTIES = new Set([
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'inset',
+    'insetInline',
+    'insetBlock',
+]);
 /**
  * Classifies the sign of a leading numeric length in a string offset value
  * (e.g. '-6px' -> negative, '0'/'0px' -> zero, '6px' -> positive). Anything
@@ -42,11 +53,34 @@ function classifyOffsetString(raw) {
     return match[1] === '-' ? 'negative' : 'positive';
 }
 /**
- * Classifies an inset offset property value (top/right/bottom/left) as a
- * positive, negative, zero, or unknown length. Only the shapes that can be
- * resolved statically are classified; variables, member expressions, template
- * literals, and calls are treated as unknown and never counted toward the
- * hit-slop exemption.
+ * Classifies a value that may carry several space-separated lengths, as the
+ * `inset` shorthand does (up to four). A positive component anywhere outranks a
+ * negative one: it pulls an edge inside the origin box, where the overlay can
+ * occlude the control.
+ */
+function classifyOffsetComponents(raw) {
+    // A CSS function such as calc() or var() embeds whitespace inside a single
+    // component, so splitting on whitespace would misread its parts as lengths.
+    if (raw.includes('('))
+        return 'unknown';
+    const signs = raw
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(classifyOffsetString);
+    if (signs.length === 0)
+        return 'unknown';
+    if (signs.includes('positive'))
+        return 'positive';
+    if (signs.includes('negative'))
+        return 'negative';
+    return signs.every((sign) => sign === 'zero') ? 'zero' : 'unknown';
+}
+/**
+ * Classifies an inset offset property value as a positive, negative, zero, or
+ * unknown length. Only the shapes that can be resolved statically are
+ * classified; variables, member expressions, and calls are treated as unknown
+ * and never counted toward the hit-slop exemption.
  */
 function classifyOffsetValue(value) {
     if (value.type === utils_1.AST_NODE_TYPES.Literal) {
@@ -56,10 +90,18 @@ function classifyOffsetValue(value) {
             return value.value < 0 ? 'negative' : 'positive';
         }
         if (typeof value.value === 'string') {
-            return classifyOffsetString(value.value);
+            return classifyOffsetComponents(value.value);
         }
         return 'unknown';
     }
+    // An offset derived from a named constant states its direction in the leading
+    // literal text, whatever the interpolation resolves to: an interpolated
+    // negative would render `--8px`, which is not a valid length. Every other
+    // interpolation stays opaque and earns no exemption.
+    if (value.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+        const leading = value.quasis[0]?.value.raw.trim() ?? '';
+        return leading.startsWith('-') ? 'negative' : 'unknown';
+    }
     // Negative numeric literals parse as `-` UnaryExpression over a number.
     if (value.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
         value.operator === '-' &&

package/lib/rules/no-unnecessary-destructuring-rename.js

@@ -95,6 +95,49 @@ function getRenamedPropertyInfo(property) {
     }
     return null;
 }
+/**
+ * Node types that can sit between a renamed property and the declarator whose
+ * binding pattern it belongs to.
+ */
+const BINDING_PATTERN_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.ObjectPattern,
+    utils_1.AST_NODE_TYPES.ArrayPattern,
+    utils_1.AST_NODE_TYPES.AssignmentPattern,
+    utils_1.AST_NODE_TYPES.RestElement,
+    utils_1.AST_NODE_TYPES.Property,
+]);
+/**
+ * Reports whether `pattern` destructures an `export const { … } = …`
+ * declaration.
+ *
+ * The alias of an exported destructuring IS the module's public export name, so
+ * collapsing `export const { id: renamedId }` to `export const { id }` renames
+ * the export. Every importer spells the old name out in a file this single-file
+ * fixer cannot reach, so the rewrite breaks them all (TS2305/TS2724) with no
+ * local symptom. The hazard therefore does not depend on how the declaring file
+ * uses the binding — a module that only re-publishes the value is the most
+ * exposed shape, not the safest. `global-const-style` and the shared rename
+ * fixer withhold their rewrites on the same grounds.
+ *
+ * The walk climbs the binding pattern rather than reading the property's
+ * immediate parent because the rename can be nested
+ * (`export const { user: { name: userName } } = data`). It stops at the first
+ * ancestor that is not part of a binding pattern, so a destructured parameter
+ * of an exported function answers false: that binding is function-local and
+ * never an export name.
+ */
+function isExportedDestructuringPattern(pattern) {
+    let current = pattern;
+    while (current && BINDING_PATTERN_TYPES.has(current.type)) {
+        current = current.parent;
+    }
+    if (!current || current.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        return false;
+    }
+    const declaration = current.parent;
+    return (declaration?.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+        declaration.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration);
+}
 exports.noUnnecessaryDestructuringRename = (0, createRule_1.createRule)({
     name: 'no-unnecessary-destructuring-rename',
     meta: {
@@ -310,10 +353,16 @@ exports.noUnnecessaryDestructuringRename = (0, createRule_1.createRule)({
             return fixes;
         }
         function reportAndFixCandidates(candidatesByPattern) {
-            for (const patternCandidates of candidatesByPattern.values()) {
+            for (const [pattern, patternCandidates] of candidatesByPattern) {
+                // The destructuring edit and the object-literal edit are one atomic
+                // batch — applying either alone leaves the file referencing a name that
+                // no longer binds — so an exported pattern withholds the whole batch and
+                // stays report-only. Every candidate in a group shares one pattern, so
+                // the export answer is a property of the group.
+                const withholdFix = isExportedDestructuringPattern(pattern);
                 patternCandidates.forEach((candidate, index) => {
                     const { propertyNode, originalName, aliasIdentifier } = candidate;
-                    const isFixCarrier = index === 0;
+                    const isFixCarrier = index === 0 && !withholdFix;
                     context.report({
                         node: propertyNode,
                         messageId: 'unnecessaryDestructuringRename',

package/lib/rules/semantic-function-prefixes.js

@@ -16,6 +16,24 @@ const NEXTJS_DATA_FUNCTIONS = new Set([
     'getStaticProps',
     'getStaticPaths',
 ]);
+/**
+ * Lexicalized verb-particle compounds whose head happens to be a disallowed
+ * prefix. "check in" names an operation exactly — its meaning is not the verb
+ * `check` applied to the object `in` — so the generic-prefix heuristic is
+ * measuring the wrong lexeme and reports a false positive.
+ *
+ * Entries are `<verb> <particle>` in lowercase and are matched against the
+ * first TWO camelCase segments, so derived names (checkInAndSet, checkOutTeam)
+ * inherit the exemption while `check` + object (checkUserPermissions) does not.
+ *
+ * Criterion for adding an entry: the verb+particle pair must be a *lexicalized*
+ * compound — a phrasal verb or domain noun whose meaning is not the sum of its
+ * parts (check in, check out) — and its head must be a disallowed prefix.
+ * A merely grammatical verb+particle sequence does NOT qualify: `getOutOfSync`,
+ * `updateInPlace`, and `processOutQueue` are compositional, so the generic verb
+ * still hides what the function does and the rule must keep reporting them.
+ */
+const COMPOUND_LEXEMES = new Set(['check in', 'check out']);
 const SUGGESTED_ALTERNATIVES = {
     get: ['fetch', 'retrieve', 'compute', 'derive'],
     update: ['modify', 'set', 'apply'],
@@ -50,6 +68,24 @@ function extractFirstWord(name) {
     }
     return firstWord;
 }
+/**
+ * The first two camelCase segments of a name, joined by a space
+ * (`checkInAndSet` -> `check in`).
+ *
+ * Whole-segment equality is load-bearing. `checkInput` segments as
+ * `check` + `Input`, so a substring test such as `name.startsWith('checkin')`
+ * would exempt it — along with checkInputValidation, CheckInputData and every
+ * other `check` + object name that merely begins with a particle's letters.
+ */
+function extractCompoundHead(name) {
+    const firstWord = extractFirstWord(name);
+    const remainder = name.slice(firstWord.length);
+    const secondWord = remainder ? extractFirstWord(remainder) : '';
+    return `${firstWord} ${secondWord}`.toLowerCase();
+}
+function isCompoundLexeme(name) {
+    return COMPOUND_LEXEMES.has(extractCompoundHead(name));
+}
 exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
     name: 'semantic-function-prefixes',
     meta: {
@@ -65,32 +101,33 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        function checkMethodName(node) {
-            // Skip getters and setters
-            if (node.kind === 'get' || node.kind === 'set') {
-                return;
-            }
-            const methodName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : '';
-            if (!methodName)
-                return;
-            // Skip if method starts with 'is' (boolean check methods are okay)
-            if (methodName.startsWith('is'))
+        /**
+         * Single detection path for every visited shape. Methods and functions
+         * differ only in which node carries the report, so sharing the guards keeps
+         * an exemption from applying to one shape and not the other.
+         */
+        function reportIfGenericPrefix(reportNode, functionName) {
+            // Skip if the name starts with 'is' (boolean check functions are okay)
+            if (functionName.startsWith('is'))
                 return;
             // Skip Next.js data-fetching functions
-            if (NEXTJS_DATA_FUNCTIONS.has(methodName))
+            if (NEXTJS_DATA_FUNCTIONS.has(functionName))
+                return;
+            // Skip compound lexemes whose head merely coincides with a banned prefix
+            if (isCompoundLexeme(functionName))
                 return;
             // Extract first word from PascalCase/camelCase
-            const firstWord = extractFirstWord(methodName);
+            const firstWord = extractFirstWord(functionName);
             // Check for disallowed prefixes
             // Only flag if the disallowed word is used as a prefix (not the entire name)
             for (const prefix of DISALLOWED_PREFIXES) {
                 if (firstWord.toLowerCase() === prefix.toLowerCase() &&
-                    firstWord.length < methodName.length) {
+                    firstWord.length < functionName.length) {
                     context.report({
-                        node: node.key,
+                        node: reportNode,
                         messageId: 'avoidGenericPrefix',
                         data: {
-                            functionName: methodName,
+                            functionName,
                             prefix,
                             alternatives: SUGGESTED_ALTERNATIVES[prefix].join(', '),
                         },
@@ -99,6 +136,16 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
                 }
             }
         }
+        function checkMethodName(node) {
+            // Skip getters and setters
+            if (node.kind === 'get' || node.kind === 'set') {
+                return;
+            }
+            const methodName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : '';
+            if (!methodName)
+                return;
+            reportIfGenericPrefix(node.key, methodName);
+        }
         function checkFunctionName(node) {
             // Skip anonymous functions
             if (!node.id && node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
@@ -115,31 +162,7 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             }
             if (!functionName)
                 return;
-            // Skip if function starts with 'is' (boolean check functions are okay)
-            if (functionName.startsWith('is'))
-                return;
-            // Skip Next.js data-fetching functions
-            if (NEXTJS_DATA_FUNCTIONS.has(functionName))
-                return;
-            // Extract first word from PascalCase/camelCase
-            const firstWord = extractFirstWord(functionName);
-            // Check for disallowed prefixes
-            // Only flag if the disallowed word is used as a prefix (not the entire name)
-            for (const prefix of DISALLOWED_PREFIXES) {
-                if (firstWord.toLowerCase() === prefix.toLowerCase() &&
-                    firstWord.length < functionName.length) {
-                    context.report({
-                        node: node.id || node,
-                        messageId: 'avoidGenericPrefix',
-                        data: {
-                            functionName,
-                            prefix,
-                            alternatives: SUGGESTED_ALTERNATIVES[prefix].join(', '),
-                        },
-                    });
-                    break;
-                }
-            }
+            reportIfGenericPrefix(node.id || node, functionName);
         }
         return {
             FunctionDeclaration: checkFunctionName,

package/lib/utils/renameFixes.js

@@ -157,11 +157,12 @@ const buildVariableRenameFixes = ({ fixer, sourceCode, variable, declarationId,
     // above. Skipping it also avoids overlapping fix ranges, which ESLint rejects.
     const references = variable.references.filter((reference) => reference.identifier !== declarationId);
     // An exported symbol is a cross-file contract whose importers a single-file
-    // fixer cannot reach. Rewriting the local use sites alone still renames the
-    // export and breaks every importer, so decline. (A bare exported declaration
-    // with no other in-file reference keeps the rename: there is nothing to
-    // orphan locally, matching the established behavior in `global-const-style`.)
-    if (references.length > 0 && isExportedDeclaration(declarationId)) {
+    // fixer cannot reach. Renaming the declaration breaks every importer, so
+    // decline. (The hazard lives entirely in those other files, so it does not
+    // depend on whether the declaring file also uses the name: a bare
+    // `export const` with no in-file reference is the most exposed shape, not the
+    // safest one. `global-const-style` withholds its rename on the same grounds.)
+    if (isExportedDeclaration(declarationId)) {
         return null;
     }
     const fixes = [declarationFix];

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,64 @@
 [
+  {
+    "version": "1.20.102",
+    "date": "2026-08-04T17:20:02.924Z",
+    "rules": [
+      {
+        "name": "ensure-pointer-events-none",
+        "changeType": "fix",
+        "issues": [
+          1707
+        ],
+        "summary": "extend the hit-slop carve-out to the inset shorthand (closes #1707)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.101",
+    "date": "2026-08-04T16:47:09.253Z",
+    "rules": [
+      {
+        "name": "enforce-centralized-mock-firestore",
+        "changeType": "fix",
+        "issues": [
+          1703
+        ],
+        "summary": "exempt the centralized module and exported declarations (closes #1703)"
+      },
+      {
+        "name": "enforce-identifiable-firestore-type",
+        "changeType": "fix",
+        "issues": [
+          1705
+        ],
+        "summary": "stay silent when the alias chain leaves the module (closes #1705)"
+      },
+      {
+        "name": "enforce-react-type-naming",
+        "changeType": "fix",
+        "issues": [
+          1701
+        ],
+        "summary": "withhold the rename for every exported declaration (closes #1701)"
+      },
+      {
+        "name": "no-unnecessary-destructuring-rename",
+        "changeType": "fix",
+        "issues": [
+          1702
+        ],
+        "summary": "withhold the fix on an exported pattern (closes #1702)"
+      },
+      {
+        "name": "semantic-function-prefixes",
+        "changeType": "fix",
+        "issues": [
+          1704
+        ],
+        "summary": "exempt the compound lexemes checkIn and checkOut (closes #1704)"
+      }
+    ]
+  },
   {
     "version": "1.20.100",
     "date": "2026-08-04T13:28:51.191Z",