@blumintinc/eslint-plugin-blumint 1.20.150 → 1.20.151

package/lib/index.js

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

package/lib/rules/enforce-exported-function-types.js

@@ -65,6 +65,42 @@ function unwrapComponentFunction(node, resolveComponent, isWrapped = false, seen
     }
     return undefined;
 }
+/**
+ * Resolves the component a default export ships.
+ *
+ * `require-memo` cannot rewrite `export default function Banner(props: P)` in
+ * place, since `export default const Banner = memo(...)` is a syntax error, so
+ * it splits the declaration from the export instead:
+ *
+ * ```
+ * const Banner = memo(function BannerUnmemoized(props: P) {...});
+ * export default Banner;
+ * ```
+ *
+ * The exported expression is then a bare identifier, and the component it
+ * stands for is one hop away on a declaration carrying no `export` of its own —
+ * invisible to every other visitor here.
+ *
+ * Following a bare identifier stays confined to the default export, where the
+ * named declaration IS the component this module ships. The named form
+ * `export const Banner = Other` re-exports a value whose props are the other
+ * declaration's concern, and an identifier belonging to another module resolves
+ * to nothing either way.
+ */
+function unwrapDefaultExportComponent(declaration, resolveComponent) {
+    if (declaration.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return unwrapComponentFunction(declaration, resolveComponent);
+    }
+    // The exported name counts as already followed, so a declaration naming
+    // itself (`const Banner = memo(Banner)`) terminates on the hop back.
+    const component = unwrapComponentFunction(resolveComponent(declaration.name), resolveComponent, false, new Set([declaration.name]));
+    if (!component)
+        return undefined;
+    return {
+        ...component,
+        resolvedName: component.resolvedName ?? declaration.name,
+    };
+}
 exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
     name: 'enforce-exported-function-types',
     meta: {
@@ -732,9 +768,10 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
             },
             // `export default memo(function Banner(props: P) {...})` mirrors the
             // `export default function Banner(props: P)` form the declaration
-            // visitors already cover.
+            // visitors already cover, as does `export default Banner` naming either
+            // of them on a separate declaration.
             ExportDefaultDeclaration(node) {
-                const component = unwrapComponentFunction(node.declaration, findModuleScopeDeclaration);
+                const component = unwrapDefaultExportComponent(node.declaration, findModuleScopeDeclaration);
                 if (!component)
                     return;
                 // The binding a wrapper argument named outranks the inner function's

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -20,7 +20,20 @@ const REFERENCE_TYPE_NAMES = new Set([
 ]);
 /**
  * The final segment of a type reference's name, so `FirebaseFirestore.
- * DocumentReference` is recognized as the same type as `DocumentReference`.
+ * DocumentReference` is read as the same name as `DocumentReference`.
+ */
+const rightmostTypeName = (typeName) => {
+    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return typeName.name;
+    }
+    if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName &&
+        typeName.right.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return typeName.right.name;
+    }
+    return undefined;
+};
+/**
+ * The reference type a name states, matched on that final segment.
  *
  * The rightmost segment is the right granularity because the namespace is
  * arbitrary — `FirebaseFirestore.`, `admin.firestore.` and any
@@ -29,16 +42,69 @@ const REFERENCE_TYPE_NAMES = new Set([
  * `DocumentReference` is not a realistic collision.
  */
 const referenceTypeNameOf = (typeName) => {
-    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return REFERENCE_TYPE_NAMES.has(typeName.name) ? typeName.name : undefined;
+    const name = rightmostTypeName(typeName);
+    return name && REFERENCE_TYPE_NAMES.has(name) ? name : undefined;
+};
+/**
+ * The type names an assertion can state that carry a document-shape generic.
+ *
+ * `Query` joins the three reference types here alone: `.where(...)` narrows a
+ * collection to it while keeping the document generic, so `as Query<User>`
+ * states the schema exactly as `as CollectionReference<User>` does. It is not a
+ * reference type the rule reports on, which is why it is not in
+ * `REFERENCE_TYPE_NAMES`.
+ */
+const SCHEMA_TYPE_NAMES = new Set([...REFERENCE_TYPE_NAMES, 'Query']);
+/**
+ * The name a type reference or an interface heritage clause states, whichever
+ * spelling names it, so `FirebaseFirestore.DocumentReference` and
+ * `DocumentReference` are read as the same type.
+ */
+const namedTypeOf = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return rightmostTypeName(node.typeName);
     }
-    if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName &&
-        typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
-        REFERENCE_TYPE_NAMES.has(typeName.right.name)) {
-        return typeName.right.name;
+    if (node.type === utils_1.AST_NODE_TYPES.TSInterfaceHeritage) {
+        const { expression } = node;
+        if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return expression.name;
+        }
+        if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            expression.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return expression.property.name;
+        }
     }
     return undefined;
 };
+/**
+ * The child nodes of a node, read generically so that every type syntax — an
+ * array, a union, a tuple, a mapped or conditional type — is traversed without
+ * enumerating the kinds one by one. `parent` is skipped because following it
+ * walks back out of the subtree and never terminates.
+ */
+const childNodesOf = (node) => {
+    const children = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'parent') {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (ASTHelpers_1.ASTHelpers.isNode(item)) {
+                    children.push(item);
+                }
+            }
+        }
+        else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+            children.push(value);
+        }
+    }
+    return children;
+};
+/** The type nodes a declaration states about the type it declares. */
+const statedTypeNodesOf = (declaration) => declaration.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration
+    ? [declaration.typeAnnotation]
+    : declaration.extends ?? [];
 /**
  * The expression an optional link wraps, so a receiver spelled with `?.` is
  * read as the expression it actually evaluates.
@@ -136,6 +202,56 @@ function declarationOfType(from, name) {
         return undefined;
     });
 }
+/**
+ * Whether an asserted type states a Firestore reference surface, and so
+ * describes the document schema of the expression it is applied to.
+ *
+ * The presence of an assertion is not evidence on its own. `as const` states no
+ * type at all — it preserves whatever the operand already infers to and adds
+ * `readonly` — so every reference beneath one keeps the loose `DocumentData`
+ * schema this rule exists to reject, byte for byte. `global-const-style` ships
+ * `error` in the same recommended config and is fixable, and its fix appends
+ * exactly that assertion to a module-scope literal, so crediting any ancestor
+ * assertion lets one `eslint --fix` pass silence the rule without repairing
+ * anything (#2007).
+ *
+ * The search is structural rather than positional, because an assertion types
+ * the references inside a literal it wraps: `[db.collection('a')] as
+ * CollectionReference<T>[]` and `{...} as Record<string, CollectionReference<T>>`
+ * both state the schema from several type nodes away. Proximity therefore
+ * cannot be the test — the minimal repro, `db.collection('x') as const`, has the
+ * assertion as the call's own parent.
+ *
+ * A name that resolves to a declaration in the file is followed, since an alias
+ * states what it stands for. Both declaration spellings are read for the reason
+ * `declaredMembersOf` reads both: `prefer-type-over-interface` ships in the same
+ * config and is fixable, so an interface and the alias it becomes have to answer
+ * alike.
+ */
+function statesDocumentSchema(node, visited) {
+    const name = namedTypeOf(node);
+    if (name) {
+        if (SCHEMA_TYPE_NAMES.has(name)) {
+            return true;
+        }
+        if (declaredTypeStatesDocumentSchema(node, name, visited)) {
+            return true;
+        }
+    }
+    return childNodesOf(node).some((child) => statesDocumentSchema(child, visited));
+}
+/**
+ * The declaration set doubles as the recursion guard, so a self-referential
+ * alias such as `type Loop = Loop[]` terminates instead of exhausting the stack.
+ */
+function declaredTypeStatesDocumentSchema(reference, name, visited) {
+    const declaration = declarationOfType(reference, name);
+    if (!declaration || visited.has(declaration)) {
+        return false;
+    }
+    visited.add(declaration);
+    return statedTypeNodesOf(declaration).some((stated) => statesDocumentSchema(stated, visited));
+}
 /**
  * @type {import('eslint').Rule.RuleModule}
  */
@@ -325,8 +441,12 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
             let previous;
             let current = node;
             while (current) {
-                // Type assertions using 'as' keyword
-                if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                // Type assertions using 'as' keyword, credited only when the asserted
+                // type states the document schema. A non-stating assertion does not end
+                // the walk: `db.doc(p) as unknown as DocumentReference<User>` reaches
+                // the stating one an assertion further out.
+                if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+                    statesDocumentSchema(current.typeAnnotation, new Set())) {
                     nodeCache.set(node, true);
                     return true;
                 }
@@ -428,7 +548,17 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                 return isTypedCollectionReferenceCache.get(node);
             }
             let result = false;
-            if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            // A receiver reached through an assertion states its schema exactly as an
+            // annotated binding does, and `isTypedCollectionInitializer` already reads
+            // the same spelling one hop later. Without this, the receiver in
+            // `(matchRef.collection('m') as CollectionReference<T>).doc(id)` looks
+            // untyped and `.doc()` draws a report whose only remedy — `doc<T>(id)` —
+            // does not compile, since `CollectionReference<T>.doc` declares zero type
+            // parameters.
+            if (node.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                result = hasCollectionReferenceType(node.typeAnnotation);
+            }
+            else if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
                 node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                 node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.callee.property.name === 'collection' &&

package/lib/rules/no-redundant-usecallback-wrapper.js

@@ -79,6 +79,46 @@ function producesFunction(factory) {
     }
     return isFunctionLiteral(unwrapValueExpression(only.argument));
 }
+/**
+ * Whether the binding is declared where the program evaluates it exactly once.
+ *
+ * A function's identity is fixed by the execution of its declaration, so what
+ * makes one a stable callback is not the function but the scope holding it.
+ * Only a module-level declaration answers yes: the scope chain reaches the
+ * `Program` without crossing a function, so nothing between the declaration and
+ * a render re-runs it. A function declared in a component body — or in any
+ * nested block of one, or in a custom hook — is a *fresh* function on every
+ * render, and there the wrapper is the only thing stabilizing it.
+ *
+ * Module-level blocks and loop bodies qualify: they run before any render, and
+ * each closure a loop creates captures the one binding it was created with.
+ */
+function isEvaluatedOnce(scope) {
+    return scope.variableScope.block.type === utils_1.AST_NODE_TYPES.Program;
+}
+/**
+ * Whether anything assigns to the binding after its declaration.
+ *
+ * The `const` keyword already rules this out for a declarator, but a function
+ * declaration binds a writable name, and the question the proof needs is about
+ * writes rather than about a keyword. Asking it of the resolved variable keeps
+ * one answer for every declaration form.
+ */
+function isNeverReassigned(variable) {
+    return variable.references.every((reference) => !reference.isWrite() || reference.init === true);
+}
+/**
+ * Whether the binding holds one function for the program's lifetime.
+ *
+ * The two questions are asked of the *binding* rather than of the syntax that
+ * introduced it, so a `const` arrow and the `function` declaration it is one
+ * rewrite away from answer alike. A proof that changed with the spelling would
+ * either withhold the report from half the codebase or bless code it flags in
+ * the other half.
+ */
+function isProgramLifetimeFunction(variable) {
+    return isEvaluatedOnce(variable.scope) && isNeverReassigned(variable);
+}
 function isHookLikeName(name) {
     return name.startsWith('use');
 }
@@ -237,7 +277,7 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
         };
         /**
          * Whether the binding this identifier resolves to holds a callback whose
-         * memoization is visible in this very file.
+         * stability is visible in this very file.
          *
          * `memoizedHookNames` exists for callbacks whose stability only the consumer
          * knows about. A `const` initialized from `useCallback`, `useLatestCallback`
@@ -247,6 +287,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
          * which the rule can report nothing at all in a config that does not set
          * `memoizedHookNames`.
          *
+         * A module-level function is the same proof without the call: a memoizing
+         * hook exists to give a function one identity across renders, and a
+         * declaration the program evaluates once already has one.
+         *
          * The binding is resolved through scope analysis rather than matched by
          * name, because a name set cannot tell the memoized `inner` of one component
          * from the `inner` prop of the next, and would report the prop — the wrapper
@@ -258,6 +302,11 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                 return false;
             }
             const declarator = variable.defs[0].node;
+            // A function declaration binds the function itself, so the binding's
+            // lifetime settles it outright — there is no initializer to read.
+            if (declarator.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                return isProgramLifetimeFunction(variable);
+            }
             if (declarator.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
                 declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
                 !declarator.init) {
@@ -277,6 +326,16 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                 return false;
             }
             const init = unwrapValueExpression(declarator.init);
+            // A function literal needs no memoizing call to be stable: it is created
+            // once by its declaration, so a module-level one holds a single identity
+            // for the program's lifetime — at least as stable as anything `useMemo`
+            // or `useCallback` hands back, and stable for the same reason. The
+            // conservative stance stays in force for *calls*: `memoize(fn)` is an
+            // unknown function whose result the rule cannot reason about, whatever it
+            // returns, and hoisting such a call to module scope does not change that.
+            if (isFunctionLiteral(init)) {
+                return isProgramLifetimeFunction(variable);
+            }
             if (init.type !== utils_1.AST_NODE_TYPES.CallExpression) {
                 return false;
             }

package/lib/rules/no-unused-props.js

@@ -6,6 +6,62 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const PAREN_TYPE = utils_1.AST_NODE_TYPES.TSParenthesizedType ??
     'TSParenthesizedType';
+/**
+ * `require-memo` rewrites `const Widget = (props: WidgetProps) => ...` into
+ * `const Widget = memo(...)`, and pairs that wrapper with `forwardRef` whenever
+ * a ref is forwarded, so a component declarator's initializer is a wrapper CALL
+ * at least as often as it is a function. Peeling them is what keeps the
+ * recommended config's own autofix from hiding the component from this rule
+ * (#2004).
+ */
+const COMPONENT_WRAPPERS = new Set(['memo', 'forwardRef']);
+const isComponentWrapperCallee = (callee) => {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_WRAPPERS.has(callee.name);
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_WRAPPERS.has(callee.property.name);
+    }
+    return false;
+};
+/**
+ * The function that receives the props behind any nesting of component
+ * wrappers (`memo(forwardRef(fn))`), or `null` when no function is reachable.
+ * Only the first argument is followed: a wrapper's remaining arguments are
+ * comparators (`memo(fn, compareDeeply('used'))`), never the component.
+ *
+ * An argument that merely NAMES a function (`memo(WidgetUnmemoized)`) is left
+ * alone, unlike in `enforce-exported-function-types`. That name belongs to a
+ * declarator of its own, which reaches this rule on its own and reports against
+ * the same props-type member; following the binding would report every unused
+ * prop once per binding that re-wraps the component.
+ */
+const unwrapComponentFunction = (node) => {
+    if (!node) {
+        return null;
+    }
+    // ESTree wraps `memo?.(fn)` and `React?.memo(fn)` in a ChainExpression, so an
+    // optionally-called wrapper sits one node deeper than the plain spelling.
+    if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return unwrapComponentFunction(node.expression);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return node;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        isComponentWrapperCallee(node.callee)) {
+        const [firstArgument] = node.arguments;
+        // A spread argument (`memo(...candidates)`) hides which value is wrapped.
+        if (!firstArgument || firstArgument.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+            return null;
+        }
+        return unwrapComponentFunction(firstArgument);
+    }
+    return null;
+};
 exports.noUnusedProps = (0, createRule_1.createRule)({
     name: 'no-unused-props',
     meta: {
@@ -469,14 +525,17 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
          * holds no props-typed function. Each declarator answers on its own: this
          * rule reports a member of a props type and rewrites nothing, so a sibling
          * binding in the same statement has no bearing on the verdict (#1890).
+         *
+         * The props come from the wrapped function's own parameter, so a wrapper
+         * changes nothing about the verdict — only about how far in the function
+         * sits. The declarator's binding still supplies any FC-shaped annotation.
          */
         const componentUsageOfDeclarator = (declaration) => {
-            const { init } = declaration;
-            if (init?.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
-                init?.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+            const fn = unwrapComponentFunction(declaration.init);
+            if (!fn) {
                 return null;
             }
-            return componentUsageOfFunction(init, declaration.id);
+            return componentUsageOfFunction(fn, declaration.id);
         };
         return {
             TSTypeAliasDeclaration(node) {

package/lib/rules/prefer-use-base62-id.js

@@ -35,6 +35,37 @@ function isHookName(name) {
 function isPascalCase(name) {
     return /^[A-Z]/.test(name);
 }
+/**
+ * Wrappers that exist purely at the type level: they leave the wrapped
+ * expression's runtime value untouched, so a value wrapped in them is still the
+ * value the enclosing declarator binds.
+ */
+const TYPE_ONLY_WRAPPERS = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+/**
+ * `require-memo` rewrites `const Widget = (props) => ...` into
+ * `const Widget = memo(...)`, and pairs that wrapper with `forwardRef` whenever
+ * a ref is forwarded, so a component's function reaches this rule behind a
+ * wrapper CALL at least as often as it sits directly under its declarator.
+ * Climbing them is what keeps the recommended config's own autofix from hiding
+ * the component from every handler here (#2005).
+ */
+const COMPONENT_WRAPPERS = new Set(['memo', 'forwardRef']);
+function isComponentWrapperCallee(callee) {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_WRAPPERS.has(callee.name);
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_WRAPPERS.has(callee.property.name);
+    }
+    return false;
+}
 /**
  * Checks whether a node is a React component or hook function.
  * Hooks: function whose name starts with "use" followed by an uppercase letter.
@@ -47,15 +78,53 @@ function isComponentOrHook(node) {
     }
     // FunctionExpression or ArrowFunctionExpression assigned to a variable:
     // const MyComponent = () => {} or const useHook = () => {}
-    const parent = node.parent;
-    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
-        const id = parent.id;
+    const declarator = getBindingDeclarator(node);
+    if (declarator) {
+        const id = declarator.id;
         if (id.type === utils_1.AST_NODE_TYPES.Identifier) {
             return isPascalCase(id.name) || isHookName(id.name);
         }
     }
     return false;
 }
+/**
+ * The declarator whose binding names the given function, seen through the
+ * wrappers that may stand between the two, or undefined when the function is
+ * not bound by a declarator at all.
+ *
+ * Only the FIRST argument of a wrapper is followed: a wrapper's remaining
+ * arguments are comparators (`memo(Widget, compareDeeply('id'))`), which run per
+ * comparison rather than per render and are no part of the component. Wrappers
+ * nest (`memo(forwardRef(fn))`), so the climb loops.
+ */
+function getBindingDeclarator(node) {
+    let child = node;
+    let current = node.parent;
+    while (current) {
+        // A type-only wrapper may sit on either side of the call, as in
+        // `const Widget = memo(fn) as FC`, and changes nothing at runtime.
+        // ESTree wraps `memo?.(fn)` and `React?.memo(fn)` in a ChainExpression, so
+        // an optionally-called wrapper sits one node deeper than the plain
+        // spelling.
+        if (TYPE_ONLY_WRAPPERS.has(current.type) ||
+            current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+            child = current;
+            current = current.parent;
+            continue;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            isComponentWrapperCallee(current.callee) &&
+            current.arguments[0] === child) {
+            child = current;
+            current = current.parent;
+            continue;
+        }
+        break;
+    }
+    return current?.type === utils_1.AST_NODE_TYPES.VariableDeclarator
+        ? current
+        : undefined;
+}
 /**
  * Recursively searches the given node tree for any CallExpression that calls
  * one of the tracked uuidv4Base62 local names.
@@ -131,17 +200,6 @@ function hasEmptyDepsArray(callNode) {
     const deps = callNode.arguments[1];
     return (deps.type === utils_1.AST_NODE_TYPES.ArrayExpression && deps.elements.length === 0);
 }
-/**
- * Wrappers that exist purely at the type level: they leave the wrapped
- * expression's runtime value untouched, so a value wrapped in them is still the
- * value the enclosing declarator binds.
- */
-const TYPE_ONLY_WRAPPERS = new Set([
-    utils_1.AST_NODE_TYPES.TSAsExpression,
-    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
-    utils_1.AST_NODE_TYPES.TSNonNullExpression,
-    utils_1.AST_NODE_TYPES.TSTypeAssertion,
-]);
 /**
  * Returns the nearest ancestor that carries runtime meaning, skipping the
  * type-only wrappers that may sit between an expression and its binding site.

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,50 @@
 [
+  {
+    "version": "1.20.151",
+    "date": "2026-08-14T02:27:13.012Z",
+    "rules": [
+      {
+        "name": "enforce-exported-function-types",
+        "changeType": "fix",
+        "issues": [
+          2006
+        ],
+        "summary": "follow a default-exported identifier to its local memo() declaration (closes #2006)"
+      },
+      {
+        "name": "enforce-firestore-doc-ref-generic",
+        "changeType": "fix",
+        "issues": [
+          2007
+        ],
+        "summary": "require an ancestor assertion to state a document schema (closes #2007)"
+      },
+      {
+        "name": "no-redundant-usecallback-wrapper",
+        "changeType": "fix",
+        "issues": [
+          2008
+        ],
+        "summary": "treat a module-level function as a stable delegate (closes #2008)"
+      },
+      {
+        "name": "no-unused-props",
+        "changeType": "fix",
+        "issues": [
+          2004
+        ],
+        "summary": "see through memo/forwardRef wrappers require-memo emits (closes #2004)"
+      },
+      {
+        "name": "prefer-use-base62-id",
+        "changeType": "fix",
+        "issues": [
+          2005
+        ],
+        "summary": "climb wrapper calls so memo() no longer hides a component (closes #2005)"
+      }
+    ]
+  },
   {
     "version": "1.20.150",
     "date": "2026-08-13T19:12:01.840Z",