jsx-eslint/eslint-plugin-react

Features

• React - Implements custom linting rules specifically designed for the React ecosystem to improve application stability.
• JSX Syntax Validation - Validates JSX markup for structural and stylistic correctness, including indentation and bracket placement.
• Automated Code Fixes - Automatically transforms non-compliant React code structures into standardized formats using AST modifications.
• Automated Code Fix Suggestions - Provides a CLI to automatically apply fixes for detected linting violations in React code.
• Linting Configurations - Provides pre-configured sets of rules to establish reasonable defaults for syntax and component patterns.
• React Linters - Implements static analysis rules to identify performance regressions and architectural inconsistencies.
• AST Visitor Patterns - Utilizes AST visitor patterns to traverse code and trigger validation logic for React elements and components.
• Coding Best Practices - Analyzes code to identify and correct patterns that violate accessibility, performance, and framework conventions.
• Coding Standards Enforcement - Provides automated systems for maintaining project guidelines and quality constraints across React components.
• Component Architecture Rules - Enforces structural rules for components and state management to prevent complex nesting and ensure a clean project hierarchy.
• Configuration-Free Rule Sets - Provides curated, pre-defined rule sets to establish baseline code quality without manual configuration.
• JSX Scope Validation - Ensures the required variable or custom pragma is available in scope when using markup to prevent reference errors.
• Mutation Prevention - Forbids direct assignments to component state to ensure updates are performed through the proper React API.
• Project Configuration Presets - Provides pre-configured rule presets to accelerate project setup and ensure organizational standards.
• Static Analysis Rule Engines - Implements an engine for defining and executing static analysis rules that inspect JSX and React component structures.
• React Performance Optimization - Provides specialized analysis to identify and reduce unnecessary render cycles and unstable references.
• UI Element Keying - Enforces the use of unique key props for elements in iterators to maintain stable component identity.
• JSX Pattern Analysis - Detects common patterns, anti-patterns, and API misuse within JSX markup and component structures.
• Component Update Optimizations - Implements rules to enforce lifecycle methods that control re-render timing and prevent unnecessary updates.
• Code Formatting and Style - Requires or prevents line breaks after elements and expressions for consistent formatting.
• Code Style and Formatting - Enforces consistent code formatting by requiring each element to reside on its own line.
• Boolean Prop Naming - Enforces a consistent naming pattern for boolean properties across the codebase.
• State Update Race Condition Prevention - Disallows accessing the current state object inside a state update call to ensure updates use the most recent state.
• State Management Linting Rules - Identifies defined state properties that are never accessed to help remove dead code.
• Referential Default Value Validation - Replace object or array literals in default parameters with stable references to avoid performance regressions.
• Markup - Validates and corrects the indentation style for JSX elements.
• Prop - Validates and corrects the indentation style of component props.
• JSX Formatting Rules - Standardizes the placement of closing tags in multiline JSX elements.
• Security Hardening Rules - Identifies potential vulnerabilities like cross-site scripting and unsafe DOM attributes within React markup.
• Method Ordering - Organizes class component methods into a consistent sequence for better discoverability.
• Context-Aware Variable Resolution - Tracks variable resolution within JSX scopes to prevent undeclared references or false unused variable warnings.
• Destructuring Style Enforcement - Mandates or prohibits destructuring assignment for props, state, and context.
• Prop Type Strictness - Prevents the use of vague or overly general prop types by enforcing specific alternatives for better safety.
• Language-Specific Quality Standards - Enforces specific function types for components and requires display names for better debugging.
• Cross-Site Scripting Prevention - Blocks the use of javascript: URLs in markup to prevent cross-site scripting attacks.
• Iframe Sandboxing - Requires a sandbox attribute on all iframe elements to restrict content capabilities and improve security.
• Component Pattern Violations - Blocks the use of the this keyword within stateless functional components to prevent errors from mixing patterns.
• Object Property Prohibitions - Flags the use of properties known to be common security vulnerabilities to ensure unsafe content is handled with caution.
• Anchor Tag Vulnerabilities - Ensures anchor tags using target blank include the noreferrer relation to protect against security vulnerabilities.
• Stateless Functional Components - Enforces the use of pure functions for stateless components to simplify code and enable performance optimizations.
• Component Definition Constraints - Detects components declared inside other components to avoid unnecessary re-renders and state loss.
• Conditional Rendering Validations - Detects and fixes conditional rendering patterns that might accidentally output falsy values to the DOM.
• Deprecated API Detectors - Prevents reliance on unreliable patterns by flagging the use of deprecated mount state checks.
• Deprecation Management - Flags the use of outdated methods and lifecycle hooks based on a specified version to ensure current practices.
• Naming Conventions - Ensures event handler methods follow specific prefixing conventions.
• Component Naming - Requires user-defined components to follow PascalCase naming conventions.
• Display Name Requirements - Ensures components have display names for clearer and more identifiable debugging messages.
• JSX Nesting Limits - Validates that elements do not exceed a specified nesting level to prevent overly complex component structures.
• Markup Structure Constraints - Requires children to be nested between tags rather than passed as props to maintain standard markup patterns.
• Naming Conventions - Validates that state variables and setter functions follow symmetric naming patterns during destructuring.
• Configuration-Driven Rules - Provides curated rule presets to ensure consistent coding standards across different React projects.
• Prop Density Limits - Enforces a maximum number of properties on a single line to improve code readability.
• Update Cycle Restrictions - Prevents redundant render calls by flagging state updates triggered within component update cycles.
• Read-Only State Protections - Requires prop type definitions to be read-only to prevent accidental mutation of component properties.
• Render Flow Validation - Detects missing return statements in component render methods to ensure content is passed to the renderer.
• Component Prop Validations - Cross-references prop types with default values to prevent configuration mismatches in components.
• Style Guide Enforcers - Enforces the use of either ES5 or ES6 class syntax for creating components.
• Component State Patterns - Ensures class component state is initialized using a consistent pattern to maintain codebase uniformity.
• API Signature Casing Validation - Identifies incorrect capitalization in static properties and lifecycle methods to ensure API compatibility.
• Unsafe Programming Pattern Restrictions - Forbids the use of legacy lifecycle methods that are incompatible with asynchronous rendering.
• Variable Usage Analysis - Analyzes program flow to identify components or variables used within JSX before they are defined.
• Code Quality Tools - Enforces consistent naming conventions and component structures to maintain high software quality.
• Type-Aware Linting - Leverages type information to identify defined property types that are never referenced within a component.
• Dead Component Code Detection - Identifies class methods and properties that are defined but never referenced within the component to reduce dead code.
• Duplicate Prop Detection - Detects and disallows the use of multiple identical properties on a single element to avoid unexpected behavior.
• Duplicate Prop Spreading Detection - Blocks the use of the same identifier spread multiple times within a single element to avoid unintentional overrides.
• HTML Attribute Validation - Checks that attributes on specific HTML elements use only valid, recognized values to prevent configuration errors.
• Inline Function Detection - Removes arrow functions or bind calls from props to stop unnecessary re-renders caused by changing function references.
• React Component Best Practices - Detects the use of array indices as keys in list elements to ensure stable identity and prevent unnecessary renders.
• Default Prop Ordering - Enforces alphabetical ordering of default property declarations in components to improve discoverability.
• Property Validation - Identifies missing keys in iterators and improper naming conventions for boolean component properties.
• Property Placement Rules - Requires component static properties to be declared in a specific position within classes to maintain consistent structure.
• Forbidden Prop Detection - Blocks the use of forbidden props on DOM nodes or specific components to prevent invalid attribute usage.
• Prop Sorting - Enforces alphabetical ordering of props in elements to make them easier to locate and maintain.
• Component Prop Validation - Ensures every property defined in default settings has a corresponding non-required type definition to prevent refactoring errors.
• Declaration Sorting - Enforces alphabetical ordering of prop type definitions to make it easier to locate specific declarations.
• Exact Prop Matching - Flags generic prop definitions to ensure components only accept explicitly defined properties.
• Default Property Values - Ensures consistency by requiring default values for any component property not marked as required.
• Markup Entity Validation - Detects characters in markup that could be mistaken for escape sequences and requires replacement with HTML entities.
• Prop Spreading Restrictions - Prevents the use of spread attributes in markup to ensure components explicitly define the props they receive.
• Declarative Style Objects - Mandates the use of object-based style declarations for consistent styling.
• Direct DOM Access Restrictions - Blocks the use of legacy DOM lookup methods to ensure compatibility with future rendering optimizations.
• Definition Syntax Enforcement - Requires functional components to be defined using a specific syntax for stylistic consistency.
• Context Memoization - Ensures context provider values use stable object identities to prevent unnecessary re-renders of consumers.
• State Centralization Enforcement - Prevents the use of internal component state to ensure application state remains centralized.
• State Update Loop Detectors - Detects synchronous state updates that would otherwise trigger redundant re-renders or infinite loops.
• Mount-Phase Update Prevention - Identifies state updates within initial mount lifecycle methods to eliminate unnecessary first-pass re-renders.
• डेवलपमेंट टूल्स - Linting rules specifically for React codebases.

स्टार हिस्ट्री