@blumintinc/eslint-plugin-blumint 1.21.2 → 1.21.4

package/lib/rules/no-inline-component-prop.js

@@ -35,6 +35,12 @@ const DEFAULT_OPTIONS = {
     allowModuleScopeFactories: true,
 };
 const INLINE_COMPONENT_NAME = 'inline component';
+/**
+ * Names followed through wrapper calls before declining. The shapes a fixer
+ * emits need two (`const X = memo(XUnmemoized)`, plus one wrapper above it);
+ * the bound is what keeps a cycle or a long chain from walking the scope graph.
+ */
+const MAX_ALIAS_HOPS = 3;
 function isPascalCase(name) {
     return /^[A-Z][A-Za-z0-9]*$/.test(name);
 }
@@ -144,25 +150,42 @@ function getCalleeName(callee) {
     }
     return null;
 }
-function getFunctionFromCall(call) {
+const WRAPPER_CALLEE_NAMES = new Set([
+    'useCallback',
+    'React.useCallback',
+    'useMemo',
+    'React.useMemo',
+    'memo',
+    'React.memo',
+    'forwardRef',
+    'React.forwardRef',
+]);
+/**
+ * `resolveIdentifier` is what lets `memo(Inner)` be judged at all. `require-memo`
+ * rewrites a nested component into `function InnerUnmemoized() {...}` plus
+ * `const Inner = memo(InnerUnmemoized)`, so reading only an inline literal here
+ * made that rewrite silence this rule while the hazard survived: the renamed
+ * declaration is still recreated per render, and `memo` re-invoked on a fresh
+ * argument yields a fresh component type. Callers that cannot decide where the
+ * name is declared pass no resolver and keep the literal-only reading.
+ */
+function getFunctionFromCall(call, resolveIdentifier) {
     const calleeName = getCalleeName(call.callee);
-    const firstArg = unwrapExpression(call.arguments[0] ?? null);
-    if (!firstArg || !isFunctionNode(firstArg)) {
+    if (!calleeName || !WRAPPER_CALLEE_NAMES.has(calleeName)) {
         return undefined;
     }
-    if (calleeName === 'useCallback' ||
-        calleeName === 'React.useCallback' ||
-        calleeName === 'useMemo' ||
-        calleeName === 'React.useMemo' ||
-        calleeName === 'memo' ||
-        calleeName === 'React.memo' ||
-        calleeName === 'forwardRef' ||
-        calleeName === 'React.forwardRef') {
+    const firstArg = unwrapExpression(call.arguments[0] ?? null);
+    if (!firstArg)
+        return undefined;
+    if (isFunctionNode(firstArg)) {
         return firstArg;
     }
+    if (firstArg.type === utils_1.AST_NODE_TYPES.Identifier && resolveIdentifier) {
+        return resolveIdentifier(firstArg);
+    }
     return undefined;
 }
-function getFunctionFromInit(init) {
+function getFunctionFromInit(init, resolveIdentifier) {
     const unwrapped = unwrapExpression(init);
     if (!unwrapped)
         return undefined;
@@ -170,7 +193,7 @@ function getFunctionFromInit(init) {
         return unwrapped;
     }
     if (unwrapped.type === utils_1.AST_NODE_TYPES.CallExpression) {
-        return getFunctionFromCall(unwrapped);
+        return getFunctionFromCall(unwrapped, resolveIdentifier);
     }
     return undefined;
 }
@@ -348,6 +371,52 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * Follows an identifier in a wrapper call's argument position to the
+         * function it names, declining wherever the reference does not prove
+         * per-render churn.
+         *
+         * Every decline below is a name whose binding is NOT recreated by the
+         * consuming render, or one this rule cannot see the definition of at all:
+         * an unresolved name (import, global, ambient), a parameter, a catch or
+         * class binding, a name declared more than once, a binding assigned more
+         * than once (its identity is not fixed by any single declaration), and a
+         * declaration outside the consuming scope. Only a single-write `Variable`
+         * or `FunctionName` declared by the very function whose JSX passes it along
+         * churns per render.
+         */
+        function resolveLocalFunction(identifier, consumerFunction, seen) {
+            // An alias chain is bounded so a cycle (`const A = memo(A)`) and a long
+            // re-export chain both terminate rather than recursing on the scope graph.
+            if (seen.size >= MAX_ALIAS_HOPS)
+                return undefined;
+            const variable = findVariableInScopes(context, identifier);
+            if (!variable || seen.has(variable))
+                return undefined;
+            seen.add(variable);
+            if (variable.defs.length !== 1)
+                return undefined;
+            const definition = variable.defs[0];
+            if (definition.type !== 'Variable' &&
+                definition.type !== 'FunctionName') {
+                return undefined;
+            }
+            const writeCount = variable.references.filter((reference) => reference.isWrite()).length;
+            if (writeCount > 1)
+                return undefined;
+            const defNode = definition.node;
+            if (resolvedOptions.allowModuleScopeFactories &&
+                isStableForConsumer(defNode, consumerFunction)) {
+                return undefined;
+            }
+            if (defNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                return defNode;
+            }
+            if (defNode.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return getFunctionFromInit(defNode.init, (next) => resolveLocalFunction(next, consumerFunction, seen));
+            }
+            return undefined;
+        }
         function shouldReportDefinition(definition, displayName, consumerFunction) {
             if (definition.type === 'ImportBinding' ||
                 definition.type === 'Parameter' ||
@@ -364,7 +433,7 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
                 fnNode = defNode;
             }
             else if (defNode.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
-                fnNode = getFunctionFromInit(defNode.init);
+                fnNode = getFunctionFromInit(defNode.init, (identifier) => resolveLocalFunction(identifier, consumerFunction, new Set()));
             }
             else {
                 return false;

package/lib/rules/no-restricted-properties-fix.js

@@ -3,6 +3,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRestrictedPropertiesFix = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Mirrors `global-const-style`'s own `toUpperSnakeCase`: both must agree on
+ * what a camelCase name becomes so that a config `object` string written
+ * before the sibling rule's rename still recognizes the code after it
+ * (Issue #2318 -- `global-const-style` renames a module-scope
+ * `disallowedObject` const to `DISALLOWED_OBJECT`, and a purely spelling-based
+ * match against `disallowedObject` goes silent on the renamed identifier even
+ * though the same restricted property is still being read off it). Splitting
+ * on case *boundaries* rather than just uppercasing keeps acronym runs intact
+ * and reproduces the sibling rule's output exactly.
+ */
+function toUpperSnakeCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .toUpperCase()
+        .replace(/^_/, '');
+}
+/** Whether `name` already has the exact shape `global-const-style` emits. */
+function isUpperSnakeCase(name) {
+    return /^[A-Z][A-Z0-9_]*$/.test(name);
+}
+/**
+ * Matches a configured `object` name against an identifier, tolerating the
+ * one rewrite `global-const-style` performs on it: a module-scope const
+ * renamed from camelCase to UPPER_SNAKE_CASE. The match stays restricted to
+ * identifiers that are ALREADY in that exact UPPER_SNAKE_CASE shape --
+ * comparing case-insensitively across the board would also equate a
+ * configured `foo` with an unrelated PASCAL-cased `Foo` (a React component
+ * name, say), which `global-const-style` never rewrites and which the
+ * configured `foo` was never meant to reach. Restricting the tolerant branch
+ * to names `global-const-style` could plausibly have produced keeps the
+ * broadened match tied to the one rename it is compensating for, rather than
+ * a blanket case-insensitive comparison that would invite false positives on
+ * unrelated identifiers.
+ */
+function objectNameMatches(identifierName, configuredName) {
+    return (identifierName === configuredName ||
+        (isUpperSnakeCase(identifierName) &&
+            identifierName === toUpperSnakeCase(configuredName)));
+}
 /**
  * This rule is a wrapper around the core ESLint no-restricted-properties rule
  * that adds special handling for Object.keys() and Object.values() results.
@@ -98,7 +139,7 @@ exports.noRestrictedPropertiesFix = (0, createRule_1.createRule)({
                 for (const restrictedProp of restrictedProperties) {
                     const objectMatches = restrictedProp.object &&
                         node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.object.name === restrictedProp.object;
+                        objectNameMatches(node.object.name, restrictedProp.object);
                     const propertyMatches = restrictedProp.property &&
                         ((node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                             node.property.name === restrictedProp.property) ||
@@ -124,9 +165,18 @@ exports.noRestrictedPropertiesFix = (0, createRule_1.createRule)({
                         restrictedProp.property &&
                         propertyMatches) {
                         // Check if the object is in the allowObjects list
-                        if (restrictedProp.allowObjects &&
+                        const objectIdentifierName = node.object.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? node.object.name
+                            : '';
+                        // `allowObjects` names a BINDING exactly as `object` does, so it
+                        // must tolerate the same UPPER_SNAKE_CASE rewrite. Normalizing only
+                        // the restrictive side would let `global-const-style`'s rename turn
+                        // an explicitly allowed access (`router.push`) into a reported one
+                        // (#2318).
+                        const allowObjects = restrictedProp.allowObjects;
+                        if (allowObjects &&
                             node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            restrictedProp.allowObjects.includes(node.object.name)) {
+                            allowObjects.some((allowed) => objectNameMatches(objectIdentifierName, allowed))) {
                             continue;
                         }
                         const objectName = node.object.type === utils_1.AST_NODE_TYPES.Identifier

package/lib/rules/no-useless-usememo-primitives.js

@@ -80,16 +80,44 @@ function isStringLikeWithoutTypes(expr) {
 function rangesOverlap(a, b) {
     return a[0] < b[1] && b[0] < a[1];
 }
-function isUseMemoCallee(callee) {
+/**
+ * The memo hooks this rule governs, by the name they are called under.
+ *
+ * `useDeepCompareMemo` (from `@blumintinc/use-deep-compare`) mirrors `useMemo`
+ * argument for argument — a callback whose result is cached against a
+ * dependency array — so every judgement below reads the same call shape and
+ * every rewrite produces the same text. Memoizing a primitive is equally
+ * pointless under it: a value with no identity to preserve gains nothing from a
+ * cache, and deep comparison makes the bargain WORSE rather than acceptable,
+ * since each render now walks the dependency array by value to protect it.
+ *
+ * They are enumerated rather than matched by prefix because a fixable,
+ * recommended sibling rewrites the callee of a `useMemo` to the deep-compare
+ * spelling to repair a dependency-identity problem, leaving the callback
+ * byte-identical. Keyed on the literal `useMemo` alone, this rule went silent on
+ * the result while the useless memoization it objects to survived the rename
+ * untouched — renaming the callee by hand reproduces the blind spot with no
+ * fixer involved (#2312).
+ */
+const MEMO_HOOK_NAMES = new Set(['useMemo', 'useDeepCompareMemo']);
+/**
+ * The hook a call invokes, or `null` where it is not a memo hook at all.
+ *
+ * A namespaced call answers with the bare hook name rather than the whole
+ * callee text, so `React.useMemo` and `useMemo` report identically: the
+ * namespace is the caller's import style, not part of what the report is about.
+ */
+function memoHookNameOf(callee) {
     if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return callee.name === 'useMemo';
+        return MEMO_HOOK_NAMES.has(callee.name) ? callee.name : null;
     }
     if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
         !callee.computed &&
         callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return callee.property.name === 'useMemo';
+        const { name } = callee.property;
+        return MEMO_HOOK_NAMES.has(name) ? name : null;
     }
-    return false;
+    return null;
 }
 function getReturnedExpression(callback) {
     if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
@@ -320,7 +348,7 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            uselessUseMemoPrimitive: 'useMemo wraps a primitive {{valueKind}}. → Primitives are pass-by-value and have no identity to preserve, so memoization provides zero referential-stability benefit and only adds unnecessary hook overhead. → Remove useMemo and inline the expression directly.',
+            uselessUseMemoPrimitive: '{{hook}} wraps a primitive {{valueKind}}. → Primitives are pass-by-value and have no identity to preserve, so memoization provides zero referential-stability benefit and only adds unnecessary hook overhead. → Remove {{hook}} and inline the expression directly.',
         },
     },
     defaultOptions: [DEFAULT_OPTIONS],
@@ -361,9 +389,9 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
             });
         }
         /**
-         * Every `useMemo` call the rule reports, in traversal order.
+         * Every memo-hook call the rule reports, in traversal order.
          *
-         * Reporting is deferred to `Program:exit` because the `useMemo` import is
+         * Reporting is deferred to `Program:exit` because the hook's import is
          * unbound only once no surviving call references it. Judged one call at a
          * time, a file with two of them never sees either as the binding's last
          * use, and the pass that unwraps both resolves every report — so nothing
@@ -630,7 +658,8 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
         }
         return {
             CallExpression(node) {
-                if (!isUseMemoCallee(node.callee)) {
+                const hook = memoHookNameOf(node.callee);
+                if (!hook) {
                     return;
                 }
                 if (node.arguments.length === 0) {
@@ -677,16 +706,18 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
                 if (!isPrimitive) {
                     return;
                 }
-                violations.push({ node, returnedExpression, valueKind });
+                violations.push({ node, returnedExpression, valueKind, hook });
             },
             'Program:exit'() {
                 if (violations.length === 0)
                     return;
                 const planned = planViolations();
-                // One plan over every surviving rewrite: the `useMemo` binding is left
+                // One plan over every surviving rewrite: the hook's binding is left
                 // unreferenced by their union even when no single unwrap strips its
                 // last use, and the pass that applies them all resolves every report —
-                // so this is the only moment the stranded import is visible.
+                // so this is the only moment the stranded import is visible. Which
+                // binding that is comes from the deletions themselves, so the
+                // deep-compare import is unbound on the same terms as React's.
                 const importRemoval = planned.length > 0
                     ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, planned.flatMap((entry) => entry.removed))
                     : null;
@@ -705,6 +736,7 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
                         node: violation.node,
                         messageId: 'uselessUseMemoPrimitive',
                         data: {
+                            hook: violation.hook,
                             valueKind: violation.valueKind,
                         },
                         fix: violation === carrier?.violation

package/lib/rules/prefer-destructuring-no-class.js

@@ -114,16 +114,52 @@ function isStaticClassMember(node, context) {
     return false;
 }
 /**
- * Check if the property name matches the variable name in an assignment
+ * Extracts the literal name a MemberExpression's property spells, when that
+ * name is comparable to a binding identifier (an Identifier's own name, or a
+ * string Literal's value). A non-string literal (e.g. `obj[0]`) can never
+ * equal an identifier name, so it is excluded here rather than at every
+ * caller.
  */
-function isMatchingPropertyName(propertyNode, variableName) {
+function getComparablePropertyName(propertyNode) {
     if (propertyNode.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return propertyNode.name === variableName;
+        return propertyNode.name;
     }
-    if (propertyNode.type === utils_1.AST_NODE_TYPES.Literal) {
-        return propertyNode.value === variableName;
+    if (propertyNode.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof propertyNode.value === 'string') {
+        return propertyNode.value;
     }
-    return false;
+    return null;
+}
+/**
+ * Check if the property name matches the variable name in an assignment
+ */
+function isMatchingPropertyName(propertyNode, variableName) {
+    return getComparablePropertyName(propertyNode) === variableName;
+}
+/**
+ * Strips underscores and lowercases a name so a SCREAMING_SNAKE_CASE binding
+ * compares equal to the camelCase property it reads (`MY_VALUE` vs
+ * `myValue`), not merely a pure case shift (`FOO` vs `foo`). A rename tool
+ * such as `global-const-style` reshapes only the BINDING to fit a naming
+ * convention; it never touches the property expression on the right-hand
+ * side, so the two spellings diverge in casing and word separators without
+ * the assignment becoming a genuine rename of what the binding refers to.
+ */
+function normalizeForLooseNameMatch(name) {
+    return name.replace(/_/g, '').toLowerCase();
+}
+/**
+ * Case/underscore-insensitive counterpart to `isMatchingPropertyName`, used
+ * only where `enforceForRenamedProperties` is off. The default gate must
+ * still recognize `const FOO = obj.foo;` as the same property access it
+ * recognizes for `const foo = obj.foo;` (#2316), while a genuinely different
+ * name (`TOTAL` vs `count`) keeps failing the match.
+ */
+function isMatchingPropertyNameIgnoringCase(propertyNode, variableName) {
+    const propertyName = getComparablePropertyName(propertyNode);
+    return (propertyName !== null &&
+        normalizeForLooseNameMatch(propertyName) ===
+            normalizeForLooseNameMatch(variableName));
 }
 /**
  * Get the property text for destructuring
@@ -235,13 +271,20 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
             if (isPrivateIdentifierProperty(memberExpression.property)) {
                 return false;
             }
+            // `super.x` has no destructurable form: `const { x } = super;` is a
+            // syntax error, since `super` must be followed by a call or a member
+            // access. Reachable for any binding whose name matches the property in
+            // any casing, so the guard belongs here rather than at one call site.
+            if (memberExpression.object.type === utils_1.AST_NODE_TYPES.Super) {
+                return false;
+            }
             if (!options.object) {
                 return false;
             }
             if (options.enforceForRenamedProperties) {
                 return true;
             }
-            return isMatchingPropertyName(memberExpression.property, identifier.name);
+            return isMatchingPropertyNameIgnoringCase(memberExpression.property, identifier.name);
         }
         function getPatternKeyText(memberExpression, propertyText) {
             if (memberExpression.computed) {
@@ -254,9 +297,15 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
                 return null;
             }
             const patternKeyText = getPatternKeyText(memberExpression, propertyText);
+            // Alias whenever the destructured key would not itself spell the
+            // target binding: a computed key never can, and any literal spelling
+            // mismatch — an explicit rename under `enforceForRenamedProperties`,
+            // or a case/underscore-only difference the default gate now tolerates
+            // (#2316) — must keep `key: target`, or the emitted destructuring
+            // binds the wrong name (or, for `const { FOO } = OBJ;` where the
+            // property is `foo`, no name at all).
             if (memberExpression.computed ||
-                (options.enforceForRenamedProperties &&
-                    !isMatchingPropertyName(memberExpression.property, targetName))) {
+                !isMatchingPropertyName(memberExpression.property, targetName)) {
                 return `${patternKeyText}: ${targetName}`;
             }
             return patternKeyText;
@@ -323,8 +372,13 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
         function buildReportDetails(memberExpr, targetName, examplePrefix, exampleSuffix) {
             const objectText = sourceCode.getText(memberExpr.object);
             const propertyText = getPropertyText(memberExpr.property, memberExpr.computed, sourceCode);
-            const usesRenaming = options.enforceForRenamedProperties &&
-                !!targetName &&
+            // Tracks whether the FIXED destructuring needs an alias — the same
+            // question `getDestructuringBindingText` answers — so the message
+            // wording ("with renaming", the target-name note) stays truthful for
+            // a case/underscore-only spelling difference the default gate now
+            // reports (#2316), not only for an explicit
+            // `enforceForRenamedProperties` rename.
+            const usesRenaming = !!targetName &&
                 !isMatchingPropertyName(memberExpr.property, targetName);
             const aliasName = targetName ?? propertyText;
             const patternKeyText = getPatternKeyText(memberExpr, propertyText);

package/lib/rules/prefer-document-flattening.js

@@ -20,6 +20,63 @@ function isObjectExpression(node) {
 function isProperty(node) {
     return node.type === utils_1.AST_NODE_TYPES.Property;
 }
+/**
+ * Resolves the property name every static spelling of a key denotes:
+ * `shouldFlatten`, `'shouldFlatten'` and `['shouldFlatten']` all occupy the
+ * same slot, so a literal that writes one of them cannot gain another without
+ * duplicating the key. A key built from an expression denotes an unknown
+ * property and yields no name.
+ */
+function staticKeyName(property) {
+    const key = property.key;
+    if (!property.computed && isIdentifier(key)) {
+        return key.name;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        key.expressions.length === 0 &&
+        key.quasis.length === 1) {
+        return key.quasis[0].value.cooked;
+    }
+    return undefined;
+}
+/**
+ * The single answer to "does this options literal already write shouldFlatten".
+ * The reader that decides whether to report and the writer that builds the
+ * suggestion share it so they cannot disagree about which members exist: a
+ * writer that misses a member the reader sees appends a duplicate key.
+ */
+function findShouldFlattenProperty(options) {
+    for (const property of options.properties) {
+        if (!isProperty(property))
+            continue;
+        if (staticKeyName(property) === 'shouldFlatten') {
+            return property;
+        }
+    }
+    return undefined;
+}
+function isLiteralBoolean(node, expected) {
+    return node.type === utils_1.AST_NODE_TYPES.Literal && node.value === expected;
+}
+/**
+ * Flattening counts as enabled only for a literal `true`. A variable, a
+ * ternary or a call may evaluate either way, so those are treated as unknown
+ * and the violation is still reported.
+ */
+function hasEnabledShouldFlatten(newExpr) {
+    if (newExpr.arguments.length < 2) {
+        return false;
+    }
+    const optionsArg = newExpr.arguments[1];
+    if (!isObjectExpression(optionsArg)) {
+        return false;
+    }
+    const property = findShouldFlattenProperty(optionsArg);
+    return !!property && isLiteralBoolean(property.value, true);
+}
 /**
  * Appends an entry to a comma-separated list by anchoring on its last element
  * and deriving the separator from whatever already follows that element.
@@ -105,6 +162,18 @@ exports.preferDocumentFlattening = (0, createRule_1.createRule)({
                 if (!isObjectExpression(optionsArg)) {
                     return null;
                 }
+                const existing = findShouldFlattenProperty(optionsArg);
+                if (existing) {
+                    // Appending a second `shouldFlatten` member is never correct: the
+                    // literal would carry the key twice (TS1117, and core no-dupe-keys).
+                    // A literal `false` is rewritten in place; any other value — a
+                    // variable, a ternary, a call, a shorthand reference, an accessor —
+                    // may already be true, so the edit is declined rather than guessed.
+                    if (isLiteralBoolean(existing.value, false)) {
+                        return fixer.replaceText(existing.value, 'true');
+                    }
+                    return null;
+                }
                 const lastEntry = optionsArg.properties[optionsArg.properties.length - 1];
                 if (!lastEntry) {
                     // An empty object offers no entry to anchor on, so the opening brace
@@ -148,25 +217,8 @@ exports.preferDocumentFlattening = (0, createRule_1.createRule)({
                 // Only check DocSetter and DocSetterTransaction classes
                 if (className !== 'DocSetter' && className !== 'DocSetterTransaction')
                     return;
-                // Check if shouldFlatten option is provided
-                let hasShouldFlatten = false;
                 // The options object is typically the second argument
-                if (node.arguments.length >= 2) {
-                    const optionsArg = node.arguments[1];
-                    if (isObjectExpression(optionsArg)) {
-                        for (const property of optionsArg.properties) {
-                            if (!isProperty(property))
-                                continue;
-                            if (isIdentifier(property.key) &&
-                                property.key.name === 'shouldFlatten' &&
-                                property.value.type === utils_1.AST_NODE_TYPES.Literal &&
-                                property.value.value === true) {
-                                hasShouldFlatten = true;
-                                break;
-                            }
-                        }
-                    }
-                }
+                const hasShouldFlatten = hasEnabledShouldFlatten(node);
                 // Get variable name from parent node if it's a variable declaration
                 let instanceName = '';
                 if (node.parent &&
@@ -203,23 +255,7 @@ exports.preferDocumentFlattening = (0, createRule_1.createRule)({
                     const className = object.callee.name;
                     if (className === 'DocSetter' ||
                         className === 'DocSetterTransaction') {
-                        let hasShouldFlatten = false;
-                        if (object.arguments.length >= 2) {
-                            const optionsArg = object.arguments[1];
-                            if (isObjectExpression(optionsArg)) {
-                                for (const property of optionsArg.properties) {
-                                    if (!isProperty(property))
-                                        continue;
-                                    if (isIdentifier(property.key) &&
-                                        property.key.name === 'shouldFlatten' &&
-                                        property.value.type === utils_1.AST_NODE_TYPES.Literal &&
-                                        property.value.value === true) {
-                                        hasShouldFlatten = true;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
+                        const hasShouldFlatten = hasEnabledShouldFlatten(object);
                         if (!hasShouldFlatten) {
                             instance = {
                                 className,