PluginBench
Rule

svelte

via PatrickJS/awesome-cursorrules

Svelte best practices for component structure, reactivity, state management, and modern web applications

What is svelte?

This rule provides guidance on building scalable Svelte applications with proper component architecture, TypeScript integration, and SvelteKit patterns. Use it when developing Svelte components to ensure clean structure, efficient reactivity, and maintainable code.

  • Structure components with proper TypeScript typing, props, and event dispatching
  • Implement reactive declarations, stores, and derived values for state management
  • Use SvelteKit for routing with layouts, parameters, and error handling
  • Build forms with bindings, validation, and proper error handling
  • Optimize performance with lazy loading, transitions, and key blocks
  • Configure Vite-based build setup with code splitting and environment variables

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

Senior full-stack TypeScript, React, Node.js guidance with clean architecture, testing, and WHY-oriented reasoning.

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

Quantitative factor research skills for designing, evaluating, and mining alpha factors in equities markets.

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

Android development with Jetpack Compose, clean architecture, and Material Design 3.

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

Angular development with Novo Elements UI library using standalone components.

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

Expert Angular 18 + TypeScript development with Jest, emphasizing clean code and performance.

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

Manage Kubernetes clusters, add-ons, stacks, and credentials via the Ankra CLI platform.

**/*.sh +5
41k
via PatrickJS/awesome-cursorrules