Browse

App Deployment .cursorrules strategies

Filters

Tech

Clear

Chrome extension APIs

Tanstack Query

expo-secure-store

Expo SDK

expo-notifications

Server Components

Lucide

NativeWind

react-native.

Github

Stripe

Server Actions

Replicate

Anthropic

Deepgram

docker-compose

LSM tree

MVCC (Multi-Version Concurrency Control)

containerization technologies

Dockerfile

cProfile

database algorithms

asyncio

B+ tree

WAL (Write-Ahead Logging)

multiprocessing

B-tree

functional programming

GitHub Actions.

boto3

python

flask-cors

FUE5

flask

conda

SVG

gunicorn

svgwrite

CSS.

Clerk Auth

mySQL

tailwindcss.

Flask-RESTful

Flask-Caching

Flask-SQLAlchemy

Flasgger.

Flask-JWT-Extended

Flask-RESTX

Flask-Migrate

SplashScreen

react-native-i18n

React's Suspense

Views

Blueprints

expo-error-reporter

React Native

expo-updates

expo-constants

react-native-gesture-handler

react-native-safe-area-context

React Context

Redux Toolkit

react-native-encrypted-storage

expo-permissions

AppLoading

expo-localization

Extensions.

react-native-reanimated

react-query

expo-linking

useReducer

Symfony

postgres

Sqlite3

SQLAlchemy 2.0

Magic UI

Go's testing package

net/http

ServeMux

log

HTTP

React three fiber

Three.js

Cypress.

Cloudflare Workers

Cloudflare D1

EAS

Jotai

Deno

@tanstack/react-query

react-copy-to-clipboard

@rainbow-me/rainbowkit

react-hot-toast

nextjs

eslint-config-prettier

eslint

daisyui

abitype

vercel

@types/nprogress

TypeScript Expo Jest Detox .cursorrules prompt file

You are an expert in TypeScript, React Native, Expo, and Mobile UI development.

Code Style and Structure

Write concise, technical TypeScript code with accurate examples.
Use functional and declarative programming patterns; avoid classes.
Prefer iteration and modularization over code duplication.
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
Structure files: exported component, subcomponents, helpers, static content, types.
Follow Expo's official documentation for setting up and configuring your projects: https://docs.expo.dev/

Naming Conventions

Use lowercase with dashes for directories (e.g., components/auth-wizard).
Favor named exports for components.

TypeScript Usage

Use TypeScript for all code; prefer interfaces over types.
Avoid enums; use maps instead.
Use functional components with TypeScript interfaces.
Use strict mode in TypeScript for better type safety.

Syntax and Formatting

Use the "function" keyword for pure functions.
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
Use declarative JSX.
Use Prettier for consistent code formatting.

UI and Styling

Use Expo's built-in components for common UI patterns and layouts.
Implement responsive design with Flexbox and Expo's useWindowDimensions for screen size adjustments.
Use styled-components or Tailwind CSS for component styling.
Implement dark mode support using Expo's useColorScheme.
Ensure high accessibility (a11y) standards using ARIA roles and native accessibility props.
Leverage react-native-reanimated and react-native-gesture-handler for performant animations and gestures.

Safe Area Management

Use SafeAreaProvider from react-native-safe-area-context to manage safe areas globally in your app.
Wrap top-level components with SafeAreaView to handle notches, status bars, and other screen insets on both iOS and Android.
Use SafeAreaScrollView for scrollable content to ensure it respects safe area boundaries.
Avoid hardcoding padding or margins for safe areas; rely on SafeAreaView and context hooks.

Performance Optimization

Minimize the use of useState and useEffect; prefer context and reducers for state management.
Use Expo's AppLoading and SplashScreen for optimized app startup experience.
Optimize images: use WebP format where supported, include size data, implement lazy loading with expo-image.
Implement code splitting and lazy loading for non-critical components with React's Suspense and dynamic imports.
Profile and monitor performance using React Native's built-in tools and Expo's debugging features.
Avoid unnecessary re-renders by memoizing components and using useMemo and useCallback hooks appropriately.

Navigation

Use react-navigation for routing and navigation; follow its best practices for stack, tab, and drawer navigators.
Leverage deep linking and universal links for better user engagement and navigation flow.
Use dynamic routes with expo-router for better navigation handling.

State Management

Use React Context and useReducer for managing global state.
Leverage react-query for data fetching and caching; avoid excessive API calls.
For complex state management, consider using Zustand or Redux Toolkit.
Handle URL search parameters using libraries like expo-linking.

Error Handling and Validation

Use Zod for runtime validation and error handling.
Implement proper error logging using Sentry or a similar service.
Prioritize error handling and edge cases:
Handle errors at the beginning of functions.
Use early returns for error conditions to avoid deeply nested if statements.
Avoid unnecessary else statements; use if-return pattern instead.
Implement global error boundaries to catch and handle unexpected errors.
Use expo-error-reporter for logging and reporting errors in production.

Testing

Write unit tests using Jest and React Native Testing Library.
Implement integration tests for critical user flows using Detox.
Use Expo's testing tools for running tests in different environments.
Consider snapshot testing for components to ensure UI consistency.

Security

Sanitize user inputs to prevent XSS attacks.
Use react-native-encrypted-storage for secure storage of sensitive data.
Ensure secure communication with APIs using HTTPS and proper authentication.
Use Expo's Security guidelines to protect your app: https://docs.expo.dev/guides/security/

Internationalization (i18n)

Use react-native-i18n or expo-localization for internationalization and localization.
Support multiple languages and RTL layouts.
Ensure text scaling and font adjustments for accessibility.

Key Conventions

Rely on Expo's managed workflow for streamlined development and deployment.
Prioritize Mobile Web Vitals (Load Time, Jank, and Responsiveness).
Use expo-constants for managing environment variables and configuration.
Use expo-permissions to handle device permissions gracefully.
Implement expo-updates for over-the-air (OTA) updates.
Follow Expo's best practices for app deployment and publishing: https://docs.expo.dev/distribution/introduction/
Ensure compatibility with iOS and Android by testing extensively on both platforms.

API Documentation