Browse

Firebase Best Practices .cursorrules strategies

Filters

Tech

Clear

tokio::sync::oneshot

async programming

tokio-postgres

Result

tokio::time::sleep

tokio::sync::mpsc

tonic

json

React JSX

aiohttp

tenacity

lxml

1. requests

BeautifulSoup

React hooks

SecureStore.

React Navigation

Ignite

MobX State Tree

localStorage

Firestore

NextAuth

LLM

NLP

sphinx

Nodejs

Puppeteer 🤔

Reactjs

OpenAI GPT-3

SocketIO

skimage.restoration

tqdm.notebook

nibabel

os

image_utils

jupyter

SimpleITK

totalsegmentator

Airbnb’s JavaScript Style Guide

serverless architecture

JSON-ld

DOM manipulation

CSS-Variables

E-L-D loading pattern

vanilla JavaScript

C++

LDoc

Emscripten

Lua

Defold

i18next

Turbo

react-i18next

nativewind

1. React

class-validator

jest

Logger

Client Components

Server-Side Rendering (SSR)

Next.js Image component

App Router

caching

1. Next.js 14

error boundaries

Static Site Generation (SSG)

revalidation

`fetch` API

Java Concurrency utilities

Java Platform Module System

JavaDocs

ConcurrentHashMap

JUnit

Functional Interfaces

ArrayList

Lambda Expressions

IDEs

HashMap

try-with-resources

three.js

jsonwebtoken

Nodemailer

EJS

OpenAPI 3.0

Swagger-ui-express

Sinon

Winston

Bunyan

Sequelize

MercadoPago

supertest

PM2

New Relic

ELK stack

APIs

MercadoPago SDK

Datadog

Swagger-jsdoc

Google Cloud

Helmet

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: