···11-Version: 3.x
22-33-# Advanced APIs
44-55-## measure
66-77-measure lets you synchronously get the dimensions and position of a view on the screen, all on the UI thread.
88-99-## useAnimatedReaction
1010-1111-useAnimatedReaction allows you to respond to changes in a shared value. It's especially useful when comparing values previously stored in the shared value with the current one.
1212-1313-## useFrameCallback
1414-1515-useFrameCallback lets you run a function on every frame update.
1616-1717-## useEvent
1818-1919-useEvent is a low-level hook. It returns event handler that will be called when native event occurs. You can use it to create custom event handler hooks, like useScrollViewOffset or useAnimatedScrollHandler.
2020-2121-## useHandler
2222-2323-useHandler is a low-level hook. It returns a context object and a value that tells you if the worklet needs to be rebuilt. You can use it to create custom event handler hooks, like useScrollViewOffset or useAnimatedScrollHandler.
2424-2525-## useComposedEventHandler
2626-2727-This is a hook that lets you compose useEvent-based event handlers (such as useAnimatedScrollHandler or your own custom ones) into a single, combined event handler.
2828-2929-## dispatchCommand
3030-3131-dispatchCommand allows you to run commands on a native component from the UI thread directly.
3232-3333-## setNativeProps
3434-3535-setNativeProps lets you imperatively update component properties.
3636-3737-## makeMutable
3838-3939-The usage of makeMutable is discouraged in most cases. It's recommended to use the useSharedValue hook instead unless you know what you're doing and you are aware of the consequences (see the Remarks section).
···11-Version: 3.x
22-33-# Animations
44-55-## withTiming
66-77-withTiming lets you create an animation based on duration and easing.
88-99-## withSpring
1010-1111-withSpring lets you create spring-based animations.
1212-1313-## withDecay
1414-1515-withDecay lets you create animations that mimic objects in motion with friction. The animation will start with the provided velocity and slow down over time according to the given deceleration rate until it stops.
1616-1717-## withSequence
1818-1919-withSequence is an animation modifier that lets you run animations in a sequence.
2020-2121-## withRepeat
2222-2323-withRepeat is an animation modifier that lets you repeat an animation given number of times or run it indefinitely.
2424-2525-## withDelay
2626-2727-withDelay is an animation modifier that lets you start an animation with a delay.
2828-2929-## withClamp
3030-3131-withClamp is an animation modifier that lets you limit the scope of movement of your animation to make it stay within some predefined range.
···11-Version: 3.x
22-33-# Core
44-55-## useSharedValue
66-77-useSharedValue lets you define shared values in your components.
88-99-## useAnimatedStyle
1010-1111-useAnimatedStyle lets you create a styles object, similar to StyleSheet styles, which can be animated using shared values.
1212-1313-## useAnimatedProps
1414-1515-useAnimatedProps lets you create an animated props object which can be animated using shared values. This object is used to animate properties of third-party components.
1616-1717-## useAnimatedRef
1818-1919-useAnimatedRef lets you get a reference of a view. Used alongside measure, scrollTo, and useScrollViewOffset functions.
2020-2121-## useDerivedValue
2222-2323-useDerivedValue lets you create new shared values based on existing ones while keeping them reactive.
2424-2525-## createAnimatedComponent
2626-2727-createAnimatedComponent lets you create an Animated version of any React Native component. Wrapping a component with createAnimatedComponent allows Reanimated to animate any prop or style associated with that component.
2828-2929-## cancelAnimation
3030-3131-cancelAnimation lets you cancel a running animation paired to a shared value.
···11-# Accurate Call Stacks
22-33-When debugging Reanimated code, you may encounter error or warning call stacks that don't clearly indicate the root cause of the problem. These stacks can be misleading, as they often highlight code from Reanimated's internals rather than the misuse of the Reanimated API that is the source of the problem.
···11-# ReducedMotionConfig
22-33-ReducedMotionConfig component let's you change behavior in response to the device's reduced motion accessibility setting. By default it disables all animation when the reduced motion is enabled on a device. You can adjust it for your specific use case. You can learn more about Accessibility and useReducedMotion in Reanimated.
···11-# Animating styles and props
22-33-In the last section, we learned how to make simple animations, what shared values are and how to use them. Now, we'll learn a different way of passing animation styles to components. We'll also go over the difference between animating styles and props and how to handle them using useAnimatedStyle and useAnimatedProps.
···11-Version: 3.x
22-33-# Guides
44-55-## Worklets
66-77-Worklets are short-running JavaScript functions that can run on the UI thread. Reanimated uses worklets to calculate view styles and react to events on the UI thread.
88-99-## Accessibility
1010-1111-In this section, we will explore how Reanimated provides support for enhanced accessibility in animations, particularly through its reduced motion functionality. This feature ensures a smoother experience for users who may have motion sensitivities or prefer less movement.
1212-1313-## Building for Android on Windows
1414-1515-This article provides basic troubleshooting steps for issues that may happen when building React Native apps with Reanimated for Android devices on Windows host machine.
1616-1717-## Compatibility
1818-1919-Currently supported React Native versions (Paper)
2020-2121-## Contributing
2222-2323-Thank you for your interest in contributing to Reanimated! From triaging and commenting on issues, through extending the documentation, to reviewing and sending Pull Requests, all contributions are more than welcome.
2424-2525-## Debugging worklets
2626-2727-Due to Reanimated's unique architecture and usage of a second JS runtime, debugging
2828-2929-## Migration from 1.x
3030-3131-We wanted to make it possible to migrate from Reanimated 1 to Reanimated 2 incrementally.
3232-3333-## Migration from 2.x
3434-3535-Reanimated 3.x doesn't introduce any breaking changes between 2.x and 3.x in terms of the API. All the code you've written in Reanimated v2 API works in 3.x without any changes. However, Reanimated 3.x drops the Reanimated v1 API entirely. For the migration guide between 1.x and 2.x versions please consult Migration from 1.x to 2.x.
3636-3737-## Testing with Jest
3838-3939-Reanimated provides testing API, based on Jest. It allows user to mock web-based animations.
4040-4141-## Troubleshooting
4242-4343-Initialization issues
4444-4545-## Web Support
4646-4747-It's possible to launch Reanimated in a web browser. For that case all of the functionalities are implemented purely in JavaScript, hence the efficiency of the animations might be lower.
···11-Version: 3.x
22-33-# Layout Animations
44-55-## Entering/Exiting animations
66-77-Entering/Exiting animations let you animate elements when they are added to or removed from the view hierarchy.
88-99-## Keyframe animations
1010-1111-Keyframes are animation definition schemas that let you create complex animations. They allow you more flexibility than standard Entering and Exiting presets.
1212-1313-## Layout transitions
1414-1515-Layout transitions allows you to replace layout changes with smooth transitions. Each layout change may include changes of size and position and both of them can be animated.
1616-1717-## Custom animations
1818-1919-Custom animations give you a full control over the Entering/Exiting animations and Layout transitions. However, they tend to be hard to understand and maintain. We recommend starting with predefined Entering/Exiting, Keyframes and Layout presets first before using custom animations.
2020-2121-## Skipping Layout Animations
2222-2323-LayoutAnimationConfig is a component that lets you skip entering and exiting animations.
2424-2525-## List Layout Animations
2626-2727-itemLayoutAnimation lets you define a layout transition that's applied when list items layout changes. You can use one of the predefined transitions like LinearTransition or create your own transition.
···11-# useAnimatedScrollHandler
22-33-useAnimatedScrollHandler is a hook that returns an event handler reference. It can be used with React Native's scrollable components.
···11-# Overview
22-33-Shared Element Transitions is an experimental feature, not recommended for production use yet. We are waiting for your feedback to improve implementation.
···11-# createWorkletRuntime
22-33-createWorkletRuntime lets you create a new JS runtime which can be used to run worklets possibly on different threads than JS or UI thread. This function is supposed to be used by third-party libraries that need to integrate with worklets. The return value represents the runtime and it's supposed to be passed to C++ side using JSI (JavaScript Interface) for further operations.
···11-# useAnimatedGestureHandler
22-33-This API is deprecated, doesn't receive any updates and will be removed in the next major version of Reanimated.
···11-Top / Right / Bottom / Left
11+# Top / Right / Bottom / Left
2233-# Usage
33+## Usage
4455Please refer to the documentation on the Tailwind CSS website
66
···11-```markdown
21# Legacy Gesture Handlers
3243## Overview
···4342## createNativeWrapper()
44434544The `createNativeWrapper()` function from the legacy API will no longer be supported. Transitioning to the gestures API is recommended. Consult the upgrading guide for more details.
4646-```
···11-```markdown
21# Handler State
3243Gesture handlers are conceptualized as "state machines" according to the description provided in "About Gesture Handlers". This means they operate through a series of states, transitioning between them based on specific inputs or events.
55-```
···11-```markdown
21# withSequence
3243`withSequence` is an animation modifier that allows animations to be executed in a sequential order.
···3534| Android | iOS | Web |
3635|---------|-----|-----|
3736| โ | โ | โ |
3838-```
···11-```markdown
22-# Advanced APIs - Version 3.x
33-44-## measure
55-66-`measure` allows synchronous retrieval of a view's dimensions and position on the screen, executed on the UI thread.
77-88-## useAnimatedReaction
99-1010-`useAnimatedReaction` enables response to changes in a shared value. It is particularly useful for comparing previous values stored in the shared value with their current counterparts.
1111-1212-## useFrameCallback
1313-1414-`useFrameCallback` facilitates running a function during each frame update.
1515-1616-## useEvent
1717-1818-`useEvent` is a foundational hook that returns an event handler triggered by native events. This can be utilized to create custom event handler hooks, such as `useScrollViewOffset` or `useAnimatedScrollHandler`.
1919-2020-## useHandler
2121-2222-`useHandler` is another fundamental hook providing a context object and a value indicating if the worklet requires rebuilding. It aids in creating custom event handler hooks like `useScrollViewOffset` or `useAnimatedScrollHandler`.
2323-2424-## useComposedEventHandler
2525-2626-This hook allows for the composition of `useEvent`-based event handlers (e.g., `useAnimatedScrollHandler` or custom ones) into a single, unified event handler.
2727-2828-## dispatchCommand
2929-3030-`dispatchCommand` enables execution of commands on a native component directly from the UI thread.
3131-3232-## setNativeProps
3333-3434-`setNativeProps` allows for imperative updates to component properties.
3535-3636-## makeMutable
3737-3838-The use of `makeMutable` is generally discouraged. It's advised to opt for the `useSharedValue` hook unless you are fully aware of its implications and consequences (refer to the Remarks section).
3939-```
···11-```markdown
22-# Animations (Version: 3.x)
33-44-## withTiming
55-66-`withTiming` allows for creating animations based on a specified duration and easing function.
77-88-## withSpring
99-1010-`withSpring` enables the creation of spring-based animations, providing a natural motion effect.
1111-1212-## withDecay
1313-1414-`withDecay` creates animations that simulate objects in motion experiencing friction. The animation begins at a given velocity and gradually slows down according to a specified deceleration rate until it comes to a stop.
1515-1616-## withSequence
1717-1818-`withSequence` is an animation modifier used for executing multiple animations one after another in sequence.
1919-2020-## withRepeat
2121-2222-`withRepeat` is an animation modifier that allows an animation to be repeated a certain number of times or indefinitely.
2323-2424-## withDelay
2525-2626-`withDelay` is an animation modifier that introduces a delay before starting the animation.
2727-2828-## withClamp
2929-3030-`withClamp` is an animation modifier used to restrict the movement range of an animation, ensuring it stays within predefined limits.
3131-```
···11-```markdown
22-# Core (Version: 3.x)
33-44-## useSharedValue
55-66-`useSharedValue` is used for defining shared values within your components. These shared values can be utilized across different parts of the component tree.
77-88-## useAnimatedStyle
99-1010-With `useAnimatedStyle`, you can create a styles object akin to StyleSheet styles, which allows animation using shared values. This enables dynamic styling changes in response to animations.
1111-1212-## useAnimatedProps
1313-1414-`useAnimatedProps` facilitates the creation of an animated props object that can be animated with shared values. It is particularly useful for animating properties of third-party components by providing them with animated props.
1515-1616-## useAnimatedRef
1717-1818-The `useAnimatedRef` function provides a reference to a view, which can then be used in conjunction with functions like measure, scrollTo, and useScrollViewOffset to manipulate the view's position or dimensions.
1919-2020-## useDerivedValue
2121-2222-`useDerivedValue` allows for the creation of new shared values derived from existing ones. This ensures that these new values remain reactive and update automatically when their dependencies change.
2323-2424-## createAnimatedComponent
2525-2626-`createAnimatedComponent` enables you to transform any React Native component into an animated version. By wrapping a component with `createAnimatedComponent`, Reanimated can animate any prop or style associated with it, enhancing the component's interactivity.
2727-2828-## cancelAnimation
2929-3030-The `cancelAnimation` function is used to stop a running animation that is linked to a shared value. This allows for greater control over animations by providing the ability to halt them when necessary.
3131-```
···11-# Accurate Call Stacks
22-33-When debugging Reanimated code, you might come across error or warning call stacks that do not clearly point to the root cause of an issue. These stacks can be misleading because they frequently emphasize code from Reanimated's internal workings instead of highlighting the misuse of the Reanimated API, which is often the actual source of the problem.
44-55-```typescript
66-// Example TypeScript snippet for context (not part of original content)
77-function debugReanimatedCode() {
88- // Debugging logic here
99-}
1010-```
1111-1212-| Aspect | Description |
1313-|-----------------------|-----------------------------------------------------------------------------|
1414-| **Issue** | Misleading call stacks in error or warning messages. |
1515-| **Cause** | Call stacks often highlight Reanimated's internal code rather than API misuse. |
1616-| **Impact** | Difficulty in identifying the true source of problems during debugging. |
1717-1818-Understanding this behavior is crucial for effectively diagnosing and resolving issues within Reanimated projects.
···11-# Reduced Motion Configuration
22-33-The `ReducedMotionConfig` component allows you to modify behavior based on the device's reduced motion accessibility setting. By default, it disables all animations when reduced motion is enabled on a device. You can customize this for your specific needs. For more information, refer to Accessibility and `useReducedMotion` in Reanimated.
44-55-```typescript
66-interface ReducedMotionConfig {
77- // Define properties or methods as needed
88-}
99-```
1010-1111-This component helps ensure that your application respects user preferences regarding motion settings.
···11-# Animating Styles and Props
22-33-In the previous section, we explored creating simple animations, understanding shared values, and their application. In this part, we will delve into an alternative method for applying animation styles to components. We'll also examine the distinctions between animating styles versus props and how to manage them using `useAnimatedStyle` and `useAnimatedProps`.
44-55-## Animating Styles with `useAnimatedStyle`
66-77-The `useAnimatedStyle` hook allows you to define animated styles that can be applied directly to a component's style prop. This approach is particularly useful for smoothly transitioning between different visual states.
88-99-### Example
1010-1111-```typescript
1212-import { useSharedValue, withSpring, useAnimatedStyle } from 'react-native-reanimated';
1313-1414-const AnimatedComponent = () => {
1515- const opacity = useSharedValue(0);
1616-1717- // Define the animated styles
1818- const animatedStyles = useAnimatedStyle(() => ({
1919- opacity: withSpring(opacity.value),
2020- }));
2121-2222- return <View style={[styles.view, animatedStyles]} />;
2323-};
2424-```
2525-2626-## Animating Props with `useAnimatedProps`
2727-2828-While `useAnimatedStyle` is great for animating styles, `useAnimatedProps` allows you to animate component props. This can be useful when the animation involves more than just visual changes.
2929-3030-### Example
3131-3232-```typescript
3333-import { useSharedValue, withTiming, useAnimatedProps } from 'react-native-reanimated';
3434-3535-const AnimatedText = () => {
3636- const fontSize = useSharedValue(14);
3737-3838- // Define animated props
3939- const animatedProps = useAnimatedProps(() => ({
4040- fontSize: withTiming(fontSize.value + 10),
4141- }));
4242-4343- return <Animated.Text style={styles.text} {...animatedProps}>Hello World</Animated.Text>;
4444-};
4545-```
4646-4747-## Key Differences
4848-4949-- **`useAnimatedStyle`:** Best for animating styles directly. It provides a way to interpolate values and apply them as inline styles.
5050-5151-- **`useAnimatedProps`:** Ideal for animating props of components that do not support direct style interpolation.
5252-5353-By understanding these hooks, you can effectively manage animations in your React Native applications, enhancing both performance and user experience.
···11-```markdown
22-# Guides
33-44-## Worklets
55-66-Worklets are brief JavaScript functions executed on the UI thread. Reanimated utilizes worklets to compute view styles and respond to events directly on the UI thread.
77-88-## Accessibility
99-1010-This section delves into how Reanimated enhances accessibility in animations, particularly through its reduced motion feature. This functionality ensures a more comfortable experience for users with motion sensitivities or those who prefer minimal movement.
1111-1212-## Building for Android on Windows
1313-1414-This article outlines basic troubleshooting steps for issues encountered when building React Native apps with Reanimated for Android devices from a Windows host machine.
1515-1616-## Compatibility
1717-1818-Currently supported React Native versions (Paper)
1919-2020-## Contributing
2121-2222-Thank you for your interest in contributing to Reanimated! Contributions, whether through triaging and commenting on issues, extending documentation, or reviewing and submitting Pull Requests, are greatly appreciated.
2323-2424-## Debugging Worklets
2525-2626-Due to Reanimated's unique architecture and its use of a secondary JS runtime, debugging worklets can be challenging.
2727-2828-## Migration from 1.x
2929-3030-We aimed to facilitate incremental migration from Reanimated 1 to Reanimated 2.
3131-3232-## Migration from 2.x
3333-3434-Reanimated 3.x introduces no breaking changes in terms of API between versions 2.x and 3.x. All code written using the Reanimated v2 API will function in 3.x without modifications. However, Reanimated 3.x completely removes support for the Reanimated v1 API. For migration guidance from 1.x to 2.x, please refer to the Migration from 1.x to 2.x guide.
3535-3636-## Testing with Jest
3737-3838-Reanimated offers a testing API based on Jest, enabling users to mock web-based animations.
3939-4040-## Troubleshooting
4141-4242-Initialization issues
4343-4444-## Web Support
4545-4646-Reanimated can be launched in a web browser. In this context, all functionalities are implemented purely in JavaScript, which may result in reduced animation efficiency.
4747-```
···11-```markdown
22-# Version 3.x: Layout Animations Overview
33-44-## Entering/Exiting Animations
55-66-These animations are designed to animate elements as they enter into or exit from the view hierarchy, providing a dynamic user experience.
77-88-## Keyframe Animations
99-1010-Keyframes offer a schema for defining complex animations. They provide greater flexibility compared to standard entering and exiting presets by allowing detailed control over animation sequences.
1111-1212-## Layout Transitions
1313-1414-Layout transitions enable smooth changes during layout updates, which may involve alterations in size or position. Both aspects can be animated to enhance visual fluidity.
1515-1616-## Custom Animations
1717-1818-Custom animations offer complete control over both entering/exiting animations and layout transitions. However, they are complex and challenging to maintain. It is advisable to start with predefined presets before opting for custom solutions.
1919-2020-## Skipping Layout Animations
2121-2222-The `LayoutAnimationConfig` component allows you to bypass entering and exiting animations when needed.
2323-2424-## List Layout Animations
2525-2626-With `itemLayoutAnimation`, you can specify a layout transition for list items during layout changes. Options include using predefined transitions like `LinearTransition` or creating custom ones.
2727-```
···11-```markdown
22-## About
33-44-### What is Reanimated Babel Plugin?
55-66-The Reanimated Babel Plugin is a tool designed to enhance the performance of animations in React Native applications. It works by transforming animation code during the build process, allowing for more efficient execution on mobile devices. By leveraging this plugin, developers can create smooth and responsive animations that run directly on the UI thread, bypassing JavaScript's limitations.
77-```
···11-```markdown
22-# `useAnimatedScrollHandler`
33-44-The `useAnimatedScrollHandler` is a custom hook designed to provide an event handler for managing animated scrolling within React Native applications. This hook integrates seamlessly with various scrollable components, enabling developers to implement smooth and responsive animations.
55-66-## Usage
77-88-To utilize the `useAnimatedScrollHandler`, you need to import it from its respective library or module where it's defined. Once imported, this hook can be invoked within a functional component to obtain an event handler reference that is specifically tailored for animated scroll events.
99-1010-### Example
1111-1212-Below is a basic example demonstrating how to use `useAnimatedScrollHandler` in conjunction with a React Native ScrollView:
1313-1414-```typescript
1515-import { useAnimatedScrollHandler } from 'react-native-reanimated';
1616-import { ScrollView, View, Text } from 'react-native';
1717-1818-const MyComponent = () => {
1919- const scrollHandler = useAnimatedScrollHandler({
2020- onScroll: (event) => {
2121- // Handle the scroll event with animation logic here
2222- console.log(event.contentOffset);
2323- },
2424- });
2525-2626- return (
2727- <ScrollView
2828- horizontal
2929- pagingEnabled
3030- showsHorizontalScrollIndicator={false}
3131- onScroll={scrollHandler}
3232- >
3333- {/* Your content goes here */}
3434- <View style={{ width: '100%', height: 200, backgroundColor: 'red' }} />
3535- <View style={{ width: '100%', height: 200, backgroundColor: 'blue' }} />
3636- <View style={{ width: '100%', height: 200, backgroundColor: 'green' }} />
3737- </ScrollView>
3838- );
3939-};
4040-4141-export default MyComponent;
4242-```
4343-4444-In this example, `useAnimatedScrollHandler` is used to create a scroll handler that logs the current content offset whenever a scroll event occurs. This setup allows for enhanced control over scrolling animations within the component.
4545-4646-## Parameters
4747-4848-The hook accepts an object with various properties that define how the scroll events should be handled:
4949-5050-- **onScroll**: A function that receives the scroll event details, such as `contentOffset`, and can contain logic to animate or respond to the scroll action.
5151-- Additional optional parameters may include `onBeginDrag`, `onActiveDrag`, `onEndDrag`, etc., depending on the specific requirements of your animation.
5252-5353-## Benefits
5454-5555-Using `useAnimatedScrollHandler` offers several advantages:
5656-5757-- **Performance**: By leveraging React Native Reanimated, this hook ensures that animations are performed smoothly and efficiently.
5858-- **Flexibility**: Developers can customize scroll behavior extensively through various event handlers.
5959-- **Integration**: Seamlessly works with existing React Native components like ScrollView, FlatList, etc.
6060-6161-By incorporating `useAnimatedScrollHandler` into your project, you can enhance the user experience with fluid and responsive scrolling animations.
6262-```
···11-```markdown
22-# Overview
33-44-The Shared Element Transition feature is currently in the experimental stage and should not be used in production environments at this time. Feedback from users is being sought to enhance its development and implementation.
55-66-## Key Points
77-88-- **Experimental Status**: The feature is still under development and testing.
99-- **Not for Production Use**: It's advised against using it in live applications until further notice.
1010-- **Feedback Requested**: User input is crucial for refining the feature.
1111-```
···11-# createWorkletRuntime
22-33-The `createWorkletRuntime` function is designed to establish a new JavaScript runtime environment specifically for executing worklets, potentially on threads distinct from those used by standard JavaScript or the UI. This functionality is primarily intended for use by third-party libraries that require integration with worklets.
44-55-Upon invocation, `createWorkletRuntime` returns an object representing the newly created runtime. This object must be communicated to the C++ side via the JavaScript Interface (JSI) to facilitate subsequent operations and interactions within the worklet environment.
···11-```markdown
22-# `useAnimatedGestureHandler`
33-44-**Note:** This API has been deprecated. It no longer receives updates and will be removed in a future major release of Reanimated.
55-66-## Overview
77-88-The `useAnimatedGestureHandler` function is part of the Reanimated library, which provides tools for creating smooth animations on React Native applications. However, due to its deprecation status, developers are advised to seek alternative solutions or APIs that offer similar functionality but with ongoing support and updates.
99-```
···11+# Entering/Exiting animations
22+13The provided content outlines a comprehensive guide for using various animations in React Native with the `react-native-reanimated` library. Below is a structured summary of the key points and features:
2435### Overview
···8082- **iOS**: Supported
8183- **Web**: Supported
82848383-This guide provides developers with the tools to create and customize animations effectively across multiple platforms using `react-native-reanimated`.8585+This guide provides developers with the tools to create and customize animations effectively across multiple platforms using `react-native-reanimated`.
···11+# Accessibility
22+13### Overview of Accessibility Features in React Native
2435React Native provides several accessibility features that help developers create applications usable by everyone, including people with disabilities. These features are crucial for ensuring inclusivity and compliance with accessibility standards like WCAG (Web Content Accessibility Guidelines).
···63656466#### Additional Resources
65676666-For more detailed guidance, refer to resources like "Making React Native Apps Accessible," which provides comprehensive strategies and best practices for accessibility in React Native applications.6868+For more detailed guidance, refer to resources like "Making React Native Apps Accessible," which provides comprehensive strategies and best practices for accessibility in React Native applications.
···11+# Native Components
22+13To create a native web view component in React Native, you need to implement platform-specific code for both Android and iOS. Below is a step-by-step guide on how to achieve this:
2435### Step 1: Set Up Your Project
···251253npx react-native run-ios
252254```
253255254254-This setup will allow you to use a native web view component in your React Native application, providing better performance and integration with platform-specific features.256256+This setup will allow you to use a native web view component in your React Native application, providing better performance and integration with platform-specific features.
+3-1
.cache/rewrite/reactnative.dev/docs_image.txt
···11+# Image
22+13To integrate image handling capabilities in your React Native application, you can utilize the `<Image />` component along with various methods and properties provided for efficient image management. Below is an overview of how to use these features effectively:
2435### Adding Image Support
···9395- **`srcSet`**: Allows specifying multiple image sources for different resolutions.
9496- **Cache Control**: Use `cache` property in `source` to manage caching behavior.
95979696-By leveraging these features, you can efficiently handle images in your React Native application, ensuring optimal performance and user experience.9898+By leveraging these features, you can efficiently handle images in your React Native application, ensuring optimal performance and user experience.
···11+# Key Concepts
22+13To integrate React Native into an existing iOS application, follow these steps carefully. This guide assumes you have a basic understanding of both iOS development using Xcode and JavaScript/React Native.
2435### Prerequisites
···142144143145For release builds, ensure the script phase for bundling JS and images is correctly configured. Test thoroughly on both simulators and real devices.
144146145145-By following these steps, you should be able to integrate React Native into your existing iOS application successfully. Continue developing using React Native's extensive documentation for further guidance.147147+By following these steps, you should be able to integrate React Native into your existing iOS application successfully. Continue developing using React Native's extensive documentation for further guidance.
···11+# ScrollView
22+13The provided documentation outlines various properties and methods associated with a ScrollView component, likely from a mobile development framework such as React Native. Below is a summary of the key features:
2435### Properties
···4850 - Scroll to specific coordinates with optional animation (`scrollTo`).
4951 - Automatically scroll to the end of content (`scrollToEnd`).
50525151-These properties and methods provide extensive control over scrolling behavior, performance optimization, and user interaction within a ScrollView component.5353+These properties and methods provide extensive control over scrolling behavior, performance optimization, and user interaction within a ScrollView component.
+3-1
.cache/rewrite/reactnative.dev/docs_text.txt
···11+# Text
22+13Here's a structured overview and explanation of the `Text` component in React Native, focusing on its properties and usage:
2435### Overview
···63656466### Conclusion
65676666-The `Text` component in React Native is highly customizable, supporting various styling and accessibility options. Understanding its properties allows developers to create rich, interactive text elements tailored to specific application needs.6868+The `Text` component in React Native is highly customizable, supporting various styling and accessibility options. Understanding its properties allows developers to create rich, interactive text elements tailored to specific application needs.
+3-1
.cache/rewrite/reactnative.dev/docs_textinput.txt
···11+# TextInput
22+13Here is a structured overview of the properties, methods, and known issues related to the `TextInput` component in React Native:
2435### Properties
···7274- **react-native#19366**: `.focus()` doesn't bring up the keyboard after closing it via back button on Android.
7375- **react-native#26799**: `secureTextEntry` doesn't work with `keyboardType="email-address"` or `keyboardType="phone-pad"` on Android.
74767575-This overview provides a comprehensive guide to using and understanding the `TextInput` component in React Native, including its properties, methods, and known issues.7777+This overview provides a comprehensive guide to using and understanding the `TextInput` component in React Native, including its properties, methods, and known issues.
···11+# Cross-Platform Native Modules (C++)
22+13Creating a cross-platform native module using C++ is an efficient way to share platform-agnostic code between Android and iOS. This guide walks through the process of creating a pure C++ Turbo Native Module, which allows you to write your logic once and reuse it across platforms.
2435### Prerequisites
···317319318320### Conclusion
319321320320-You've successfully created a C++ Turbo Native Module that works on both Android and iOS. This setup allows you to write platform-agnostic code in C++, reducing redundancy and improving maintainability across platforms.322322+You've successfully created a C++ Turbo Native Module that works on both Android and iOS. This setup allows you to write platform-agnostic code in C++, reducing redundancy and improving maintainability across platforms.
···11+# Native Modules
22+13To implement a cross-platform `localStorage` solution using React Native's TurboModule system, you need to set up both Android and iOS platforms. Below is a step-by-step guide based on the provided instructions:
2435### Android Setup
···244246 yarn run ios
245247 ```
246248247247-This setup provides a consistent `localStorage` API across both platforms using React Native's TurboModule system.249249+This setup provides a consistent `localStorage` API across both platforms using React Native's TurboModule system.
···11-```markdown
22-## Content Rules in Nativewind
11+# Content Rules in Nativewind
3243Nativewind adheres to the same content configuration guidelines as Tailwind CSS. For detailed information and solutions to potential issues, consult the official Tailwind CSS documentation.
55-```
66-77-This reformatted markdown maintains the original message while ensuring clarity and conciseness for an AI context.
···11-# Usage
11+# Top / Right / Bottom / Left
2233For detailed information, please consult the Tailwind CSS documentation.
44···2424| `top-auto` | ๐ Web only |
2525| `bottom-auto` | ๐ Web only |
2626| `left-auto` | ๐ Web only |
2727-| `right-auto` | ๐ Web only |2727+| `right-auto` | ๐ Web only |