React native - CodeAnt AI

no-color-literals


import React from 'react';
import { View, Text, StyleSheet } from 'react-native';

const BadExample = () => {
  return (
    <View style={styles.container}>
      <Text style={styles.text}>This is bad usage</Text>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#FFF000', // Using color literals directly
  },
  text: {
    color: 'blue', // Using color literals directly
  },
});

Promotes consistency in color usage across the application by encouraging the use of a centralized color palette, reducing the chance of slight variations in color codes leading to an inconsistent UI.
Enhances maintainability by centralizing color definitions, making it easier to update colors across the application from a single location rather than searching through individual files for hardcoded color literals.
Facilitates easier theming or style modifications since colors used throughout the app can be changed or themed without altering component files, thereby simplifying the process of theme customization or adaptation to dark/light modes.
Improves readability and organization of style-related code by separating color definitions from component styles, thereby helping developers quickly understand the color scheme being used and its application across different components without sifting through inline styles or constants within component files.

no-inline-styles


import React from 'react';
import { View, Text } from 'react-native';

const MyComponent = () => {
  return (
    <View style={{ backgroundColor: 'skyblue', padding: 20 }}>
      <Text style={{ color: 'white', fontSize: 18 }}>Hello, World!</Text>
    </View>
  );
};

This rule encourages a separation of concerns by keeping style definitions outside of the component’s render method, which leads to cleaner and more easily readable code. By extracting styles into a dedicated StyleSheet, it becomes much simpler to identify the UI elements’ styling at a glance instead of having to parse through JSX to find style objects.
It promotes reusability of styles across different components. When styles are extracted into a StyleSheet, it’s easier to reuse the same styles across multiple components without duplicating code. This can lead to a more consistent look and feel across the app and also make it easier to make global style changes from a single place.
It can lead to performance improvements in React Native applications. Inline styles in React Native are processed at runtime, which can add overhead, especially for complex components or large lists. By using StyleSheet objects, most of the processing can be moved to compile time, making the application run smoother.
The rule aids in enforcing best practices that are particularly important in larger projects. As projects grow, managing inline styles directly within components can become unwieldy and difficult to maintain. Encouraging the use of StyleSheet promotes a more scalable approach to styling that can benefit larger teams and projects by making code easier to maintain and refactor.

no-raw-text


import React from 'react';
import { View } from 'react-native';

const BadExample = () => {
  return (
    <View>
      Hello, world!
    </View>
  );
};

Ensures textual content in React Native applications is enclosed within a <Text> component or its allowed alternatives (TSpan, StyledText, Animated.Text), maintaining semantic correctness and helping in uniform text styling and rendering across the app.
Prevents raw string literals or template literals from being inadvertently used outside of text components, which can lead to unexpected behavior in UI rendering and issues with text layout in React Native.
Facilitates better accessibility practices by encouraging the proper semantic usage of text elements, making it easier to implement accessible text features such as dynamic font sizing.
Allows customization through the options.skip setting, enabling developers to extend or modify the list of elements that can safely contain text, thereby providing flexibility to accommodate project-specific components without compromising the rule’s integrity.

no-single-element-style-arrays

Disallow single element style arrays. These cause unnecessary re-renders as the identity of the array always changes


import React from 'react';
import { View, Text } from 'react-native';

const MyComponent = () => {
  return (
    <View style={[{ padding: 20 }]}>  // This line is problematic according to the rule.
      <Text>Welcome to My App</Text>
    </View>
  );
};

export default MyComponent;

This rule identifies and prevents unnecessary re-renders in React Native applications by disallowing single-element style arrays. Such arrays always change their identity, leading to performance issues.
By enforcing direct style objects instead of single-element arrays, this rule directly contributes to optimizing the rendering process of components. This optimization is crucial in mobile applications where performance and resource usage need to be efficiently managed.
The rule includes a fixer function that automatically corrects violations by replacing the single-element style array with the style object itself. This automated correction saves development time, reduces manual errors, and ensures consistency across the codebase.
Highlighting the misuse of single-element style arrays raises developers’ awareness about subtle performance pitfalls in React Native development. By adhering to this rule, developers learn to write more performant and idiomatic React Native styles, contributing to the overall quality and maintainability of the application.

no-unused-styles


import React from 'react';
import { StyleSheet, View } from 'react-native';

const styles = StyleSheet.create({
  unusedStyle: {
    padding: 20,
  },
  container: {
    flex: 1,
  },
});

const MyComponent = () => (
  <View style={styles.container}></View>
);

export default MyComponent;

Detecting unused styles helps in preventing the accumulation of dead code, leading to cleaner and more maintainable style sheets in React Native projects. In the provided rule, unusedStyle is identified as not used anywhere in the component, indicating that it can be safely removed without affecting the component’s appearance or functionality.
By removing unused styles, the rule contributes to reducing the overall size of the style object created by StyleSheet.create(). This can have a slight performance benefit, especially in large projects with many components, as it reduces the memory footprint of the application.
This rule aids in enforcing better coding practices among developers, especially in collaborative environments. It ensures that styles are only defined when needed, encouraging developers to constantly review and clean up their code, which in turn, helps in maintaining a high code quality.
Applying this rule can also assist in the early detection of potential bugs or logical errors. For example, if a style is intended to be used but is not applied due to a typo or misunderstanding of the code’s logic, the rule can signal a possible issue by indicating that the style is unused, prompting a review and correction of the code.

sort-styles


const styles = StyleSheet.create({
  container: {
    justifyContent: 'center',
    alignItems: 'center',
    padding: 10,
    margin: 20,
  },
});

This ESLint rule helps maintain a consistent ordering of style properties within React Native stylesheets, which enhances readability and manageability of the code. By enforcing a specific sequence (ascending or descending), developers can easily locate and evaluate style properties.
The rule allows for customization through options such as ignoreClassNames and ignoreStyleProperties, providing flexibility. Teams can tailor the rule to their project’s requirements, either focusing on class names, style properties, or both, depending on their coding standards or preferences.
It includes logic to handle shorthands and comments intelligently, ensuring that automatic fixes do not disrupt the code’s semantics or lose important developer annotations. This safeguards the code’s integrity while applying stylistic conventions.
The rule supports automatic fixing for uncomplicated cases where no comments are involved, significantly reducing the manual effort required to comply with the sorting order. This automatic correction feature accelerates development by quickly resolving stylistic issues without developer intervention.

split-platform-components


// File: components/MyComponent.js
import {Text} from 'react-native';

const TextIOS = () => <Text>IOS Text</Text>;
const TextAndroid = () => <Text>Android Text</Text>;

export {TextIOS, TextAndroid};

Ensures platform-specific React Native components are organized into their corresponding platform files, hence preventing unnecessary bundling of unused components for a platform which can lead to decreased app performance and increased bundle size.
Helps maintain a clean codebase by enforcing the separation of iOS and Android components, which simplifies the process of debugging and understanding code, as developers can easily identify which components are intended for each platform.
Facilitates easier implementation of platform-specific optimizations, as developers can focus on optimizing a single file for performance or integrating platform-specific APIs without worrying about impacting the other platform.
Reduces the risk of runtime errors or unwanted behavior in the application due to the accidental inclusion of platform-specific components in the wrong platform build, ensuring a more stable and reliable app experience for users.

Get Started