Browse

React.js .cursorrules prompt files

React.js is a JavaScript library for building user interfaces, offering efficient component-based structuring and fast rendering with its virtual DOM.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

Shadcn UI

JavaScript

Next.js

Python

Radix UI

JSX

WebP

Vite

Zod

Supabase

Next.js App Router

Docker

PostgreSQL

CSS

Redis

FastAPI

Pydantic

Git

Tailwind Aria

HTML

pytest

Jest

Solidity

react-hook-form

ESLint

Vercel

Vitest

SQLAlchemy

Prettier

Suspense

TailwindCSS

SvelteKit

Vue.js

Pinia

GitHub Actions

Celery

SQL

Playwright

Radix

PHP

JSDoc

VueUse

PEP 8

asyncpg

Typescript

TypeScript

Svelte

ES6

DaisyUI

Laravel

RESTful API

JSON

ARIA

Drizzle ORM

Vue Router

Astro

Shadcn

Svelte 5

OpenZeppelin

tRPC

Expo

Zustand

CORS

aiomysql

GitLab CI

Django

scikit-learn

pandas

GitHub

RabbitMQ

Rust

Java

GraphQL

WebP.

tanStackQuery

Phoenix LiveView

Ecto

File System Watcher

Plug

Finch

Gettext

Phoenix

Elixir

Jason

Phoenix LiveDashboard

Sobelow

ExCoveralls

DNS Cluster

ExUnit

Release Please

Swoosh

Credo

LeftHook

npm

styled-components

Clear

Web Development

Code Style

Frontend Development

Programming

Naming Conventions

Testing

Responsive Design

State Management

Backend Development

Programming Best Practices

Software Engineering

Code Quality

Code Optimization

Version Control

API Development

UI Design

Code Structure

Accessibility

Database Management

TypeScript Best Practices

Syntax and Formatting

Best Practices

Performance Optimization

Software Development

Coding Best Practices

Authentication

TypeScript

Security

Code Review

Data Fetching

Code Readability

Internationalization

Coding Standards

User Interface

Image Optimization

JavaScript

Object-Oriented Programming

React

performance optimization

Declarative Programming

Deployment

Error Handling

Testing and Debugging

UI Development

API Integration

SEO

UI and Styling

Programming Guidelines

Game Development

Modularization

Security Best Practices

Web Application Development

Clean Code

Smart Contracts

JavaScript Frameworks

Test-Driven Development

UI Components

Routing

TypeScript Usage

Code Organization

Coding Guidelines

Full Stack Development

Code Documentation

error handling

functional programming

CI/CD

Functional Programming

Documentation

Validation

Code Formatting

Code Modularity

Coding Style

Code Maintainability

Build and Deployment

Decentralized Applications

Artificial Intelligence

Form Validation

Web Vitals

Blockchain

Coding Practices

SEO Optimization

Blockchain Development

Dependency Injection

JavaScript Development

JavaScript Libraries

Development Workflow

Design Patterns

TypeScript Guidelines

Static Site Generation

Server-Side Rendering

Clean Code Practices

Content Management

File Organization

Form Handling

Testing and Quality Assurance

Cloud Computing

Serverless Architecture

Next.js

Node.js

React Best Practices

Show

5

rules

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Node.js MongoDB JWT Express React .cursorrules prompt file

Tech Stack:

Backend: Node.js with Express.js
Database: MongoDB with Mongoose ODM
Frontend: React.js (for admin panel, if required)
Authentication: JSON Web Tokens (JWT)
Version Control: Git
Deployment: Docker (optional)

Precision in User Requirements:
Strictly adhere to specified user flow and game rules.
Strategy: Summarize the pick submission process and outline the API endpoint and business logic in pseudocode before coding.
Strategic Planning with Pseudocode:
Begin each feature with detailed pseudocode.
Example: Provide pseudocode for the weekly scoring process, detailing steps from game result input to entry status updates.

Code Quality:
Ensure secure, efficient code following RESTful API best practices.
Implement proper error handling and input validation.

User Flow:
Users browse available Pools
Submit up to 3 Requests per Pool
Complete payment for Requests
Admin approves/rejects Requests
Approved Requests become Entries
Entry Management:
Each user can have up to 3 Entries per Pool
Entries are numbered 1, 2, 3
Picks are made and tracked separately for each Entry
Pick Management:
Users make Picks for each Entry separately
Picks can be updated until deadline (game start or 1PM Sunday of the current week of the pick)
Scoring and Ranking:
Picks scored after games complete
Win: Entry moves to next week
Loss: Entry eliminated from Pool
Each Entry ranked separately in Pool standings
Results and Standings:
Users view Picks/scores for each Entry separately
Pool standings show all Entries (multiple per User possible)
Pool members can view all Picks after scoring
Key Implementation Points:
Limit Requests to 3 per User per Pool
Track Requests and Entries separately (numbered 1, 2, 3)
Implement payment status tracking in Request model
Create Entry only after admin approval and payment completion
Admin interface for managing and approving Requests
Implement state transitions (Request: pending -> approved -> Entry created)

stack:

Node.js MongoDB JWT Express React .cursorrules prompt file

allxdamnxday

0

NEW

Node.js MongoDB .cursorrules prompt file tutorial

Tech Stack:

Backend: Node.js with Express.js
Database: MongoDB with Mongoose ODM
Frontend: React.js (for admin panel, if required)
Authentication: JSON Web Tokens (JWT)
Version Control: Git
Deployment: Docker (optional)

Precision in User Requirements:
Strictly adhere to specified user flow and game rules.
Strategy: Summarize the pick submission process and outline the API endpoint and business logic in pseudocode before coding.
Strategic Planning with Pseudocode:
Begin each feature with detailed pseudocode.
Example: Provide pseudocode for the weekly scoring process, detailing steps from game result input to entry status updates.

Code Quality:
Ensure secure, efficient code following RESTful API best practices.
Implement proper error handling and input validation.

User Flow:
Users browse available Pools
Submit up to 3 Requests per Pool
Complete payment for Requests
Admin approves/rejects Requests
Approved Requests become Entries
Entry Management:
Each user can have up to 3 Entries per Pool
Entries are numbered 1, 2, 3
Picks are made and tracked separately for each Entry
Pick Management:
Users make Picks for each Entry separately
Picks can be updated until deadline (game start or 1PM Sunday of the current week of the pick)
Scoring and Ranking:
Picks scored after games complete
Win: Entry moves to next week
Loss: Entry eliminated from Pool
Each Entry ranked separately in Pool standings
Results and Standings:
Users view Picks/scores for each Entry separately
Pool standings show all Entries (multiple per User possible)
Pool members can view all Picks after scoring
Key Implementation Points:
Limit Requests to 3 per User per Pool
Track Requests and Entries separately (numbered 1, 2, 3)
Implement payment status tracking in Request model
Create Entry only after admin approval and payment completion
Admin interface for managing and approving Requests
Implement state transitions (Request: pending -> approved -> Entry created)