Browse

react-window .cursorrules prompt files

React-window is a library for efficiently rendering large lists and tabular data by only displaying visible items, improving performance and reducing memory usage.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

Android Studio

Firebase Storage

React Native CLI

Firebase Emulator Suite

Twitter Card

sitemap.xml

Open Graph

Psycopg2-binary

Uvicorn

Python-Multipart

mysql

Nextjs 14

nuqs

Next.js SSR

Vue Router 4

Vue Test Utils

Composition API

Vue 3 Reactivity API

script setup syntax

Stylus

PurgeCSS

next-i18next

react-intl

React.memo

useState

Styled Components

FlatList

react-native-fast-image

Mobile UI

react-native-responsive-screen

EAS Build

StyleSheet.create

vi.mocked

testing-library

File Storage

internalMutation

HTTP API

db.get

react-router-dom

internal.

db.delete

db.query

cron Jobs

storage field

storage ID

GIPHY

useQuery

generateUploadUrl

Convex HTTP Actions

setState

scheduler

storage.generateUploadUrl

HTMLInputElement

db.insert

useMutation

FormEvent

Husky

Yarn

Cloudflare Pages

rubocop

minitest

Whatsapp Cloud API

YARD

Anthropic Claude

GraphQL API

CI/CD

Python 3.x

OpenAI GPT

@shopify/cli-kit

@react-three

Neo-Organic Fusion Design System

ERC-7710

forge-std

MetaMask

ERC721

ModeLib

ExecutionLib

Radix Vue

NuxtJS

Shadcn Vue

BDD

Docusaurus

Dagster

React.Suspense

react-icons

lucide-react

Shadcn/UI

reqwest

Option

tokio::time::interval

thiserror

tokio::time::pause

tokio::test

tokio::task::yield_now

tokio::sync::Mutex

hyper

serde

tokio::sync::RwLock

tokio::sync::broadcast

sqlx

Tailwind React Firebase .cursorrules prompt file

Here are some best practices and rules to follow for creating a high-quality, mobile-first web app with excellent UI/UX using Tailwind, React, and Firebase:

Mobile-First Design:

Always design and implement for mobile screens first, then scale up to larger screens.
Use Tailwind's responsive prefixes (sm:, md:, lg:, xl:) to adjust layouts for different screen sizes.

Consistent Design System:

Create a design system with consistent colors, typography, spacing, and component styles.
Utilize Tailwind's configuration file (tailwind.config.js) to define your custom design tokens.

Performance Optimization:

Use React.lazy() and Suspense for code-splitting and lazy-loading components.
Implement virtualization for long lists using libraries like react-window.
Optimize images and use next/image for automatic image optimization in Next.js.

Responsive Typography:

Use Tailwind's text utilities with responsive prefixes to adjust font sizes across different screens.
Consider using a fluid typography system for seamless scaling.

Accessibility:

Ensure proper color contrast ratios using Tailwind's text-* and bg-* classes.
Use semantic HTML elements and ARIA attributes where necessary.
Implement keyboard navigation support.

Touch-Friendly UI:

Make interactive elements (buttons, links) at least 44x44 pixels for easy tapping.
Implement touch gestures for common actions (swipe, pinch-to-zoom) where appropriate.

USE THE IMAGES IN THE MOCKUPS FOLDER AS EXAMPLE OF HOW TO STYLE THE APP AND CREATE THE LAYOUT

WHEN CREATINGA FILE DON'T CONFLICT IT WITH .TSX AND .JSX FILES

Firebase Best Practices:

Implement proper security rules in Firebase.
Use Firebase SDK's offline persistence for better performance and offline support.
Optimize queries to minimize read/write operations.

Error Handling and Feedback:

Implement proper error boundaries in React.
Provide clear feedback for user actions (loading states, success/error messages).

Animation and Transitions:

Use subtle animations to enhance UX (e.g., page transitions, micro-interactions).
Utilize Tailwind's transition utilities or consider libraries like Framer Motion.

Form Handling:

Use libraries like Formik or react-hook-form for efficient form management.
Implement proper form validation with clear error messages.

Code Organization:

Follow a consistent folder structure (e.g., components, hooks, pages, services).
Use custom hooks to encapsulate and reuse logic.

Native-like Features:

Implement pull-to-refresh for content updates.
Use smooth scrolling and momentum scrolling.
Consider using libraries like react-spring for physics-based animations.

Here’s a concise prompt for a language model to help you with the logic for creating AI-powered medication insights in your app:
Prompt:
Design a feature for a pill management app that tracks user interactions with medications (Take/Skip) and generates monthly adherence reports.
The app should:
User Interface: Display pills for "Morning," "Afternoon," and "Night" with buttons for "Take" and "Skip." Show a confirmation modal for user actions.
Data Collection: Log user interactions (pill ID, action, timestamp, notes) in a database.
Monthly Report: Aggregate data to calculate total pills scheduled vs. taken, adherence percentage, and trends (e.g., frequently skipped pills).
AI Insights: Use basic statistical analysis to generate personalized suggestions based on user feedback (e.g., side effects, missed doses).
Dashboard: Create a section for users to view their monthly reports, including adherence percentage, trends, and AI-generated suggestions.
This prompt provides a clear and structured request for assistance in developing the feature, focusing on key components and functionality.

stack: