Browse

Dart Programming .cursorrules strategies

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

Shadcn UI

JavaScript

Python

Radix UI

Next.js

Vite

JSX

WebP

Zod

Docker

Next.js App Router

Supabase

CSS

PostgreSQL

Redis

FastAPI

HTML

Pydantic

pytest

Git

Jest

react-hook-form

Solidity

Vercel

SQLAlchemy

Tailwind Aria

Suspense

SvelteKit

Vue.js

GitHub Actions

Celery

ESLint

PHP

TailwindCSS

Pinia

PEP 8

asyncpg

TypeScript

SQL

Playwright

Svelte

Prettier

Radix

DaisyUI

Vitest

JSDoc

JSON

ARIA

Drizzle ORM

Vue Router

VueUse

Astro

Svelte 5

tRPC

Expo

CORS

aiomysql

GitLab CI

Django

Typescript

scikit-learn

pandas

GitHub

RabbitMQ

Java

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

ES6

npm

Laravel

styled-components

RESTful API

Shadcn

Markdown

OpenZeppelin

Slither

Hardhat

Mythril

Clear

Syntax

Programming Rules

Code Libraries

Documentation Practices

Component-based Architecture

Payment Integration

AI Integration

Frontend Frameworks

User Flow Management

API Design

Payment Processing.

Strategic Planning

database implementation

CI/CD.

best practices

testing strategies

Code style

code structure

concurrency

parallelism

containerization

module usage

data import

environment setup

file handling

coding examples

Security Awareness

Performance Optimization.

Vite

VueUse

Tailwind

Best Practices.

Vue.js

DaisyUI

Component Naming

Descriptive Naming

File Structure

API Requests

Error handling

Project structure

AI-friendly practices

Dependency management

Configuration management

Modular design

Code style consistency

CSS Frameworks.

UI Libraries

Deployment Strategies

Type Hints

Testing and Integration

Security Practices

Mobile UI Development

UI Testing

App Deployment

Software Deployment

full stack development

code readability

performant coding

secure coding

software development best practices

AI programming assistant

JavaScript Libraries.

Programming Principles

API best practices.

Functional programming

Scalable API development

Performance optimization

Asynchronous programming

File Path Usage

Workflow Efficiency

Go programming

API development

Middleware implementation

Go concurrency

Input validation

Maintainability

Security best practices

Three.js Integration

Frontend development

State management

Modern JavaScript features

Software architecture

Full-stack development

Web development best practices

Code clarity

Programming Conventions

AI

Culinary

Web Applications

Project Guidelines

Cross-platform Development

Mobile Applications

Workflows

GitHub

Scripts

json file

package.json

dependencies

scripts

devDependencies

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Dart Flutter Best Practices .cursorrules prompt file

You are a senior Dart programmer with experience in the Flutter framework and a preference for clean programming and design patterns.

Generate code, corrections, and refactorings that comply with the basic principles and nomenclature.

Dart General Guidelines

Basic Principles

Use English for all code and documentation.
Always declare the type of each variable and function (parameters and return value).
Avoid using any.
Create necessary types.
Don't leave blank lines within a function.
One export per file.

Nomenclature

Use PascalCase for classes.
Use camelCase for variables, functions, and methods.
Use underscores_case for file and directory names.
Use UPPERCASE for environment variables.
Avoid magic numbers and define constants.
Start each function with a verb.
Use verbs for boolean variables. Example: isLoading, hasError, canDelete, etc.
Use complete words instead of abbreviations and correct spelling.
Except for standard abbreviations like API, URL, etc.
Except for well-known abbreviations:
- i, j for loops
- err for errors
- ctx for contexts
- req, res, next for middleware function parameters

Functions

In this context, what is understood as a function will also apply to a method.
Write short functions with a single purpose. Less than 20 instructions.
Name functions with a verb and something else.
If it returns a boolean, use isX or hasX, canX, etc.
If it doesn't return anything, use executeX or saveX, etc.
Avoid nesting blocks by:
Early checks and returns.
Extraction to utility functions.
Use higher-order functions (map, filter, reduce, etc.) to avoid function nesting.
Use arrow functions for simple functions (less than 3 instructions).
Use named functions for non-simple functions.
Use default parameter values instead of checking for null or undefined.
Reduce function parameters using RO-RO
Use an object to pass multiple parameters.
Use an object to return results.
Declare necessary types for input arguments and output.
Use a single level of abstraction.

Data

Don't abuse primitive types and encapsulate data in composite types.
Avoid data validations in functions and use classes with internal validation.
Prefer immutability for data.
Use readonly for data that doesn't change.
Use as const for literals that don't change.

Classes

Follow SOLID principles.
Prefer composition over inheritance.
Declare interfaces to define contracts.
Write small classes with a single purpose.
Less than 200 instructions.
Less than 10 public methods.
Less than 10 properties.

Exceptions

Use exceptions to handle errors you don't expect.
If you catch an exception, it should be to:
Fix an expected problem.
Add context.
Otherwise, use a global handler.

Testing

Follow the Arrange-Act-Assert convention for tests.
Name test variables clearly.
Follow the convention: inputX, mockX, actualX, expectedX, etc.
Write unit tests for each public function.
Use test doubles to simulate dependencies.
- Except for third-party dependencies that are not expensive to execute.
Write acceptance tests for each module.
Follow the Given-When-Then convention.

Specific to Flutter

Basic Principles

Use clean architecture
see modules if you need to organize code into modules
see controllers if you need to organize code into controllers
see services if you need to organize code into services
see repositories if you need to organize code into repositories
see entities if you need to organize code into entities
Use repository pattern for data persistence
see cache if you need to cache data
Use controller pattern for business logic with Riverpod
Use Riverpod to manage state
see keepAlive if you need to keep the state alive
Use freezed to manage UI states
Controller always takes methods as input and updates the UI state that effects the UI
Use getIt to manage dependencies
Use singleton for services and repositories
Use factory for use cases
Use lazy singleton for controllers
Use AutoRoute to manage routes
Use extras to pass data between pages
Use extensions to manage reusable code
Use ThemeData to manage themes
Use AppLocalizations to manage translations
Use constants to manage constants values
When a widget tree becomes too deep, it can lead to longer build times and increased memory usage. Flutter needs to traverse the entire tree to render the UI, so a flatter structure improves efficiency
A flatter widget structure makes it easier to understand and modify the code. Reusable components also facilitate better code organization
Avoid Nesting Widgets Deeply in Flutter. Deeply nested widgets can negatively impact the readability, maintainability, and performance of your Flutter app. Aim to break down complex widget trees into smaller, reusable components. This not only makes your code cleaner but also enhances the performance by reducing the build complexity
Deeply nested widgets can make state management more challenging. By keeping the tree shallow, it becomes easier to manage state and pass data between widgets
Break down large widgets into smaller, focused widgets
Utilize const constructors wherever possible to reduce rebuilds