PluginBench
Rule

svelte

via PatrickJS/awesome-cursorrules

Svelte best practices and patterns for modern web applications

What is svelte?

This rule provides guidance on building scalable Svelte applications with proper component structure, reactivity patterns, state management using stores, and TypeScript integration. Use it when developing Svelte components to ensure clean architecture, performance optimization, and maintainable code.

  • Structure components with proper TypeScript typing and event dispatching
  • Implement reactive declarations, derived stores, and lifecycle functions
  • Manage state using modular Svelte stores with proper subscriptions
  • Optimize performance through lazy loading, transitions, and key blocks
  • Build forms with proper bindings, validation, and error handling
  • Configure development with Vite and implement code splitting for production

Applies to

File patterns this rule matches.

**/*.svelte
src/**/*.ts
src/**/*.js
Rule definition (reference)

Source of truth, from the repository.

Svelte Best Practices

Component Structure

  • Keep components small and focused
  • Use proper TypeScript integration
  • Implement proper props typing
  • Use proper event dispatching
  • Keep markup clean and readable
  • Use proper slot implementation

Reactivity

  • Use proper reactive declarations
  • Implement proper stores
  • Use proper reactive statements
  • Handle derived values properly
  • Use proper lifecycle functions
  • Implement proper bindings

State Management

  • Use proper Svelte stores
  • Keep stores modular
  • Use proper derived stores
  • Implement proper actions
  • Handle async state properly
  • Use proper store subscriptions

Performance

  • Use proper component lazy loading
  • Implement proper transitions
  • Use proper animations
  • Avoid unnecessary reactivity
  • Use proper event forwarding
  • Implement proper key blocks

Routing

  • Use SvelteKit for routing
  • Implement proper layouts
  • Use proper route parameters
  • Handle loading states properly
  • Implement proper error pages
  • Use proper navigation methods

Forms

  • Use proper form bindings
  • Implement proper validation
  • Handle form submission properly
  • Show proper loading states
  • Use proper error handling
  • Implement proper form reset

TypeScript Integration

  • Use proper component types
  • Implement proper prop types
  • Use proper event types
  • Handle proper type inference
  • Use proper store types
  • Implement proper action types

Testing

  • Write proper unit tests
  • Implement proper component tests
  • Use proper testing libraries
  • Test stores properly
  • Implement proper mocking
  • Test async operations

Best Practices

  • Follow Svelte style guide
  • Use proper naming conventions
  • Keep components organized
  • Implement proper error handling
  • Use proper event handling
  • Document complex logic

Build and Tooling

  • Use Vite for development
  • Configure proper build setup
  • Use proper environment variables
  • Implement proper code splitting
  • Use proper asset handling
  • Configure proper optimization

Related rules

Svelte 5 migration guide: runes, snippets, and standardized event handling.

**/*
41k
via PatrickJS/awesome-cursorrules

SvelteKit + RESTful API + Tailwind CSS development guide with TDD and full file-path tracking.

**/*
41k
via PatrickJS/awesome-cursorrules

Expert SvelteKit, Tailwind CSS, and TypeScript development standards with best practices and code patterns.

**/*
41k
via PatrickJS/awesome-cursorrules

Expert guidance for SvelteKit development with TypeScript, Svelte 5 runes, and modern state management.

**/*
41k
via PatrickJS/awesome-cursorrules

Swift UIKit MVVM + RxSwift development rules for reactive iOS applications.

**/*
41k
via PatrickJS/awesome-cursorrules

Senior iOS engineer perspective on SwiftUI development with Swift 6 concurrency, SOLID principles, and performance optimization.

**/*
41k
via PatrickJS/awesome-cursorrules