@blumintinc/eslint-plugin-blumint 1.12.6 → 1.13.0

package/lib/rules/no-passthrough-getters.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noPassthroughGetters = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+const COMPLEX_EXPRESSION_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.CallExpression,
+    utils_1.AST_NODE_TYPES.TemplateLiteral,
+    utils_1.AST_NODE_TYPES.NewExpression,
+    utils_1.AST_NODE_TYPES.BinaryExpression,
+    utils_1.AST_NODE_TYPES.ArrayExpression,
+    utils_1.AST_NODE_TYPES.ObjectExpression,
+]);
+exports.noPassthroughGetters = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            // Target getter methods in classes
+            MethodDefinition(node) {
+                // Only check getter methods
+                if (node.kind !== 'get') {
+                    return;
+                }
+                // Skip if the getter has decorators (like @Memoize)
+                if (node.decorators && node.decorators.length > 0) {
+                    return;
+                }
+                const methodBody = node.value.body;
+                if (!methodBody) {
+                    return;
+                }
+                // Check if the getter body is a simple return statement
+                if (methodBody.body.length === 1 &&
+                    methodBody.body[0].type === 'ReturnStatement') {
+                    const returnStatement = methodBody
+                        .body[0];
+                    // Skip if there's no return argument
+                    if (!returnStatement.argument) {
+                        return;
+                    }
+                    // Skip if the return statement uses super
+                    if (containsSuper(returnStatement.argument)) {
+                        return;
+                    }
+                    // Skip if the return statement includes type assertions or casting
+                    if (hasTypeAssertion(returnStatement.argument)) {
+                        return;
+                    }
+                    // Skip if the return statement includes null/undefined handling
+                    if (hasNullUndefinedHandling(returnStatement.argument)) {
+                        return;
+                    }
+                    // Skip if the return statement includes computed property access or function calls
+                    if (hasComputedPropertyOrFunctionCall(returnStatement.argument)) {
+                        return;
+                    }
+                    // Check if the return statement is accessing a property from a constructor parameter
+                    if (isConstructorParameterPropertyAccess(returnStatement.argument)) {
+                        context.report({
+                            node,
+                            messageId: 'noPassthroughGetter',
+                        });
+                    }
+                }
+            },
+        };
+        /**
+         * Check if the node is a simple property access from a constructor parameter
+         * like this.settings.property or this.settings['property'] or this.settings.nested.deep.property
+         */
+        function isConstructorParameterPropertyAccess(node) {
+            // Check for member expressions like this.settings.property
+            if (node.type === 'MemberExpression') {
+                return isConstructorParameterAccess(node);
+            }
+            return false;
+        }
+        /**
+         * Check if the node is accessing a property from a constructor parameter
+         * Patterns to match: this.constructorParam.property, this.constructorParam['property'], this.constructorParam.nested.deep.property
+         * Patterns to NOT match: this.property, SomeClass.property, this.methodCall()
+         */
+        function isConstructorParameterAccess(node) {
+            let current = node.object;
+            let depth = 0;
+            // Walk up member expressions until we reach a base
+            while (current && current.type === 'MemberExpression') {
+                depth += 1;
+                current = current.object;
+            }
+            // Require at least one nesting and a base of `this`
+            return depth >= 1 && current?.type === 'ThisExpression';
+        }
+        /**
+         * Check if the node contains a reference to super
+         */
+        function containsSuper(node) {
+            let current = node;
+            while (current && current.type === 'MemberExpression') {
+                if (current.object.type === 'Super') {
+                    return true;
+                }
+                current = current.object;
+            }
+            return false;
+        }
+        /**
+         * Check if the node has a type assertion or casting
+         */
+        function hasTypeAssertion(node) {
+            if (node.type === 'TSAsExpression' || node.type === 'TSTypeAssertion') {
+                return true;
+            }
+            if (node.type === 'MemberExpression') {
+                return hasTypeAssertion(node.object);
+            }
+            return false;
+        }
+        /**
+         * Check if the node handles null/undefined values
+         */
+        function hasNullUndefinedHandling(node) {
+            // Check for logical expressions like this.settings.property || []
+            if (node.type === 'LogicalExpression') {
+                return true;
+            }
+            // Check for conditional expressions like this.settings.property ? this.settings.property : []
+            if (node.type === 'ConditionalExpression') {
+                return true;
+            }
+            // Check for optional chaining like this.settings?.property
+            if (node.type === 'MemberExpression' && node.optional) {
+                return true;
+            }
+            // The nullish coalescing check is already covered by the LogicalExpression check above
+            return false;
+        }
+        /**
+         * Check if the node includes computed property access or function calls
+         */
+        function hasComputedPropertyOrFunctionCall(node) {
+            if (COMPLEX_EXPRESSION_TYPES.has(node.type)) {
+                return true;
+            }
+            // Check for member expressions with computed properties like this.settings[key]
+            if (node.type === 'MemberExpression') {
+                // If the property is computed with a dynamic expression (not a literal), it's not a simple property access
+                if (node.computed && node.property.type !== 'Literal') {
+                    return true;
+                }
+                // Recursively check the object part
+                return hasComputedPropertyOrFunctionCall(node.object);
+            }
+            return false;
+        }
+    },
+    name: 'no-passthrough-getters',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Avoid unnecessary getter methods that simply return properties from constructor parameters',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noPassthroughGetter: 'Avoid unnecessary getter methods that simply return properties from constructor parameters. Access the property directly instead.',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=no-passthrough-getters.js.map

package/lib/rules/no-redundant-usecallback-wrapper.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        memoizedHookNames?: string[];
+        assumeAllUseAreMemoized?: boolean;
+    }
+];
+export declare const noRedundantUseCallbackWrapper: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"redundantWrapper", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default noRedundantUseCallbackWrapper;

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

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRedundantUseCallbackWrapper = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+function isHookLikeName(name) {
+    return name.startsWith('use');
+}
+function isKnownHookCallee(callee, knownHooks, assumeAllUseAreMemoized) {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return ((assumeAllUseAreMemoized && isHookLikeName(callee.name)) ||
+            knownHooks.has(callee.name));
+    }
+    // Support namespaced hook calls, e.g., Hooks.useAuthSubmit()
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        const prop = callee.property.name;
+        return ((assumeAllUseAreMemoized && isHookLikeName(prop)) || knownHooks.has(prop));
+    }
+    return false;
+}
+function isPreventDefaultCall(stmt, params) {
+    if (stmt.type !== utils_1.AST_NODE_TYPES.ExpressionStatement)
+        return false;
+    const expr = stmt.expression;
+    if (expr.type !== utils_1.AST_NODE_TYPES.CallExpression)
+        return false;
+    if (expr.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+        return false;
+    const member = expr.callee;
+    if (member.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        params.includes(member.object.name) &&
+        member.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        (member.property.name === 'preventDefault' ||
+            member.property.name === 'stopPropagation' ||
+            member.property.name === 'stopImmediatePropagation')) {
+        return true;
+    }
+    return false;
+}
+function getParams(node) {
+    const names = new Set();
+    for (const p of node.params) {
+        if (p.type === utils_1.AST_NODE_TYPES.Identifier) {
+            names.add(p.name);
+        }
+        else if (p.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            for (const prop of p.properties) {
+                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                    // Collect bound identifier names (aliases/defaults)
+                    if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        names.add(prop.value.name);
+                    }
+                    else if (prop.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                        prop.value.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        names.add(prop.value.left.name);
+                    }
+                }
+                else if (prop.type === utils_1.AST_NODE_TYPES.RestElement) {
+                    if (prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        names.add(prop.argument.name);
+                    }
+                }
+            }
+        }
+        else if (p.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+            for (const element of p.elements) {
+                if (!element)
+                    continue;
+                if (element.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    names.add(element.name);
+                }
+                else if (element.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                    element.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    names.add(element.left.name);
+                }
+                else if (element.type === utils_1.AST_NODE_TYPES.RestElement &&
+                    element.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    names.add(element.argument.name);
+                }
+            }
+        }
+    }
+    return Array.from(names);
+}
+function isIdentifierOrMemberOn(obj, nameSet) {
+    if (obj.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return nameSet.has(obj.name);
+    }
+    if (obj.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        obj.object.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return nameSet.has(obj.object.name);
+    }
+    return false;
+}
+function unwrapChainExpression(node) {
+    if (!node)
+        return null;
+    if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return node.expression;
+    }
+    return node;
+}
+// intentionally removed: helper for param-only detection not needed after simplification
+// reserved for potential future options/heuristics
+exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
+    name: 'no-redundant-usecallback-wrapper',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent wrapping already memoized/stable callbacks from hooks/contexts in an extra useCallback()',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    memoizedHookNames: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: [],
+                    },
+                    assumeAllUseAreMemoized: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            redundantWrapper: 'Redundant useCallback wrapper around an already memoized callback. Pass the memoized function directly.',
+        },
+    },
+    defaultOptions: [{}],
+    create(context) {
+        const option = context.options?.[0] ?? {};
+        const knownHooks = new Set(option.memoizedHookNames ?? []);
+        const assumeAllUseAreMemoized = option.assumeAllUseAreMemoized === true;
+        // Track identifiers coming from hook-like calls
+        const hookReturnObjects = new Set(); // variables assigned to a hook call result (object or function)
+        const hookReturnProps = new Set(); // properties destructured from a hook call result
+        return {
+            VariableDeclarator(node) {
+                if (!node.init)
+                    return;
+                const initCall = unwrapChainExpression(node.init);
+                if (!initCall || initCall.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                    return;
+                }
+                const callee = unwrapChainExpression(initCall.callee);
+                if (!callee)
+                    return;
+                if (!isKnownHookCallee(callee, knownHooks, assumeAllUseAreMemoized))
+                    return;
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    hookReturnObjects.add(node.id.name);
+                    return;
+                }
+                if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    for (const prop of node.id.properties) {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                hookReturnProps.add(prop.value.name);
+                            }
+                            else if (prop.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                                prop.value.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                hookReturnProps.add(prop.value.left.name);
+                            }
+                        }
+                    }
+                    return;
+                }
+            },
+            CallExpression(node) {
+                // Detect useCallback wrappers (including React.useCallback)
+                const calleeNode = unwrapChainExpression(node.callee);
+                if (!calleeNode)
+                    return;
+                const isUseCallback = (calleeNode.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    calleeNode.name === 'useCallback') ||
+                    (calleeNode.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        !calleeNode.computed &&
+                        calleeNode.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        calleeNode.property.name === 'useCallback');
+                if (isUseCallback && node.arguments.length >= 1) {
+                    const arg = node.arguments[0];
+                    const unwrappedArg = unwrapChainExpression(arg);
+                    // Case 1: useCallback(memoizedFn, ...) or useCallback(ctx.memoized, ...)
+                    if (unwrappedArg &&
+                        (unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier ||
+                            unwrappedArg.type === utils_1.AST_NODE_TYPES.MemberExpression)) {
+                        if ((unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            (hookReturnProps.has(unwrappedArg.name) ||
+                                hookReturnObjects.has(unwrappedArg.name))) ||
+                            (unwrappedArg.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                unwrappedArg.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                hookReturnObjects.has(unwrappedArg.object.name))) {
+                            if (unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                const replaceText = unwrappedArg.name;
+                                context.report({
+                                    node,
+                                    messageId: 'redundantWrapper',
+                                    fix: (fixer) => fixer.replaceText(node, replaceText),
+                                });
+                            }
+                            else {
+                                // Member function — report only, no fix to avoid breaking `this`.
+                                context.report({ node, messageId: 'redundantWrapper' });
+                            }
+                        }
+                        return;
+                    }
+                    // Case 2: useCallback(() => memoizedFn(...), ...)
+                    if (unwrappedArg &&
+                        (unwrappedArg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                            unwrappedArg.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                        const fn = unwrappedArg;
+                        const params = getParams(fn);
+                        // Handle implicit return: () => memoizedFn()
+                        if (fn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                            fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                            const bodyExpr = unwrapChainExpression(fn.body);
+                            if (bodyExpr && bodyExpr.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                                const callee = unwrapChainExpression(bodyExpr.callee);
+                                if ((callee &&
+                                    isIdentifierOrMemberOn(callee, hookReturnObjects)) ||
+                                    (callee &&
+                                        callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                        hookReturnProps.has(callee.name))) {
+                                    if (bodyExpr.arguments.length > 0) {
+                                        // Passing any arguments: treat as non-redundant (avoid false positives)
+                                        return;
+                                    }
+                                    else {
+                                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                            const replaceText = callee.name;
+                                            context.report({
+                                                node,
+                                                messageId: 'redundantWrapper',
+                                                fix: (fixer) => fixer.replaceText(node, replaceText),
+                                            });
+                                        }
+                                        else {
+                                            // Member function — report only, no fix to avoid breaking `this`.
+                                            context.report({ node, messageId: 'redundantWrapper' });
+                                        }
+                                    }
+                                }
+                            }
+                            return;
+                        }
+                        // Handle block body: () => { [maybe e.preventDefault()]; return memoizedFn(); }
+                        if (fn.body && fn.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                            const stmts = fn.body.body.filter(Boolean);
+                            if (stmts.length >= 1 && stmts.length <= 2) {
+                                let idx = 0;
+                                if (stmts.length === 2 &&
+                                    isPreventDefaultCall(stmts[0], params)) {
+                                    idx = 1;
+                                }
+                                const last = stmts[idx];
+                                if (last.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+                                    last.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                                    const expr = last.type === utils_1.AST_NODE_TYPES.ReturnStatement
+                                        ? last.argument
+                                        : last.expression;
+                                    if (expr && expr.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                                        const callee = unwrapChainExpression(expr.callee);
+                                        const isHookProp = callee &&
+                                            callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                            hookReturnProps.has(callee.name);
+                                        const isHookObjMember = callee &&
+                                            callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                            callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                            hookReturnObjects.has(callee.object.name);
+                                        if (isHookProp || isHookObjMember) {
+                                            if ((expr.arguments?.length ?? 0) > 0) {
+                                                // Passing any arguments: treat as non-redundant
+                                                return;
+                                            }
+                                            else {
+                                                // No args and trivial wrapper
+                                                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                                    const replaceText = callee
+                                                        .name;
+                                                    context.report({
+                                                        node,
+                                                        messageId: 'redundantWrapper',
+                                                        fix: (fixer) => fixer.replaceText(node, replaceText),
+                                                    });
+                                                }
+                                                else {
+                                                    // Member function — report only, no fix to avoid breaking `this`.
+                                                    context.report({
+                                                        node,
+                                                        messageId: 'redundantWrapper',
+                                                    });
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+exports.default = exports.noRedundantUseCallbackWrapper;
+//# sourceMappingURL=no-redundant-usecallback-wrapper.js.map

package/lib/rules/no-restricted-properties-fix.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This rule is a wrapper around the core ESLint no-restricted-properties rule
+ * that adds special handling for Object.keys() and Object.values() results.
+ * It prevents false positives when accessing standard array properties/methods
+ * on the arrays returned by Object.keys() and Object.values().
+ */
+export declare const noRestrictedPropertiesFix: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"restrictedProperty", [{
+    object?: string | undefined;
+    property?: string | undefined;
+    message?: string | undefined;
+    allowObjects?: string[] | undefined;
+}[]], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

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

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRestrictedPropertiesFix = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * This rule is a wrapper around the core ESLint no-restricted-properties rule
+ * that adds special handling for Object.keys() and Object.values() results.
+ * It prevents false positives when accessing standard array properties/methods
+ * on the arrays returned by Object.keys() and Object.values().
+ */
+exports.noRestrictedPropertiesFix = (0, createRule_1.createRule)({
+    name: 'no-restricted-properties-fix',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow certain properties on certain objects, with special handling for Object.keys() and Object.values()',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        object: { type: 'string' },
+                        property: { type: 'string' },
+                        message: { type: 'string' },
+                        allowObjects: {
+                            type: 'array',
+                            items: { type: 'string' },
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+        ],
+        messages: {
+            restrictedProperty: "Disallowed object property: '{{objectName}}.{{propertyName}}'{{message}}",
+        },
+    },
+    defaultOptions: [[]],
+    create(context, [restrictedProperties]) {
+        if (!restrictedProperties || restrictedProperties.length === 0) {
+            return {};
+        }
+        const SAFE_ARRAY_PROPERTIES = new Set([
+            'length',
+            'sort',
+            'filter',
+            'map',
+            'reduce',
+            'forEach',
+            'join',
+            'slice',
+            'concat',
+        ]);
+        /**
+         * Checks if the given node is a result of Object.keys() or Object.values()
+         * @param node The node to check
+         * @returns True if the node is a result of Object.keys() or Object.values()
+         */
+        function isObjectKeysOrValuesResult(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return false;
+            }
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            if (callee.object.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                callee.object.name !== 'Object') {
+                return false;
+            }
+            if (callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                (callee.property.name !== 'keys' && callee.property.name !== 'values')) {
+                return false;
+            }
+            return true;
+        }
+        return {
+            MemberExpression(node) {
+                // Skip if the object is a result of Object.keys() or Object.values()
+                if (isObjectKeysOrValuesResult(node.object)) {
+                    if (node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        SAFE_ARRAY_PROPERTIES.has(node.property.name)) {
+                        return;
+                    }
+                }
+                // Apply the original rule logic
+                for (const restrictedProp of restrictedProperties) {
+                    const objectMatches = restrictedProp.object &&
+                        node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.object.name === restrictedProp.object;
+                    const propertyMatches = restrictedProp.property &&
+                        ((node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            node.property.name === restrictedProp.property) ||
+                            (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                                node.property.value === restrictedProp.property));
+                    // If both object and property are restricted
+                    if (restrictedProp.object &&
+                        restrictedProp.property &&
+                        objectMatches &&
+                        propertyMatches) {
+                        context.report({
+                            node,
+                            messageId: 'restrictedProperty',
+                            data: {
+                                objectName: restrictedProp.object,
+                                propertyName: restrictedProp.property,
+                                message: restrictedProp.message
+                                    ? `: ${restrictedProp.message}`
+                                    : '',
+                            },
+                            fix: () => null,
+                        });
+                    }
+                    // If only property is restricted (for any object)
+                    else if (!restrictedProp.object &&
+                        restrictedProp.property &&
+                        propertyMatches) {
+                        // Check if the object is in the allowObjects list
+                        if (restrictedProp.allowObjects &&
+                            node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            restrictedProp.allowObjects.includes(node.object.name)) {
+                            continue;
+                        }
+                        const objectName = node.object.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? node.object.name
+                            : 'unknown';
+                        context.report({
+                            node,
+                            messageId: 'restrictedProperty',
+                            data: {
+                                objectName,
+                                propertyName: restrictedProp.property,
+                                message: restrictedProp.message
+                                    ? `: ${restrictedProp.message}`
+                                    : '',
+                            },
+                            fix: () => null,
+                        });
+                    }
+                    // If only object is restricted (any property)
+                    else if (restrictedProp.object &&
+                        !restrictedProp.property &&
+                        objectMatches) {
+                        const propertyName = node.property.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? node.property.name
+                            : node.property.type === utils_1.AST_NODE_TYPES.Literal
+                                ? String(node.property.value)
+                                : 'unknown';
+                        context.report({
+                            node,
+                            messageId: 'restrictedProperty',
+                            data: {
+                                objectName: restrictedProp.object,
+                                propertyName,
+                                message: restrictedProp.message
+                                    ? `: ${restrictedProp.message}`
+                                    : '',
+                            },
+                            fix: () => null,
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-restricted-properties-fix.js.map