PluginBench
Rule

typescript vite tailwind

via PatrickJS/awesome-cursorrules

TypeScript, Vite, Vue 3, and Tailwind setup with performance optimization and DaisyUI components.

What is typescript vite tailwind?

Establishes conventions for TypeScript development with Vite, Vue 3 (Composition API), Tailwind CSS, and DaisyUI. Emphasizes functional programming, performance optimization via code splitting and lazy loading, and responsive mobile-first design. Use this rule to maintain consistent code style, naming conventions, and best practices across a Vue 3 + Vite project.

  • Enforce TypeScript with interfaces over types, functional components, and Vue Composition API script setup syntax
  • Apply naming conventions: lowercase-dash directories, named exports, descriptive variable names with auxiliary verbs
  • Configure Tailwind CSS with DaisyUI for responsive, mobile-first UI design
  • Optimize performance via Vite code splitting, dynamic component loading, Suspense boundaries, and image optimization (WebP, lazy loading)
  • Leverage VueUse library for reactivity and performance enhancements
  • Guide code review for Web Vitals optimization, unnecessary re-renders, and bundle size reduction

Applies to

File patterns this rule matches.

**/*
Rule definition (reference)

Source of truth, from the repository.

You are an expert in TypeScript, Node.js, Vite, Vue.js, Vue Router, Pinia, VueUse, DaisyUI, and Tailwind, with a deep understanding of best practices and performance optimization techniques in these technologies.

Code Style and Structure

  • Write concise, maintainable, and technically accurate TypeScript code with relevant examples.
  • Use functional and declarative programming patterns; avoid classes.
  • Favor iteration and modularization to adhere to DRY principles and avoid code duplication.
  • Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
  • Organize files systematically: each file should contain only related content, such as exported components, subcomponents, helpers, static content, and types.

Naming Conventions

  • Use lowercase with dashes for directories (e.g., components/auth-wizard).
  • Favor named exports for functions.

TypeScript Usage

  • Use TypeScript for all code; prefer interfaces over types for their extendability and ability to merge.
  • Avoid enums; use maps instead for better type safety and flexibility.
  • Use functional components with TypeScript interfaces.

Syntax and Formatting

  • Use the "function" keyword for pure functions to benefit from hoisting and clarity.
  • Always use the Vue Composition API script setup style.

UI and Styling

  • Use DaisyUI, and Tailwind for components and styling.
  • Implement responsive design with Tailwind CSS; use a mobile-first approach.

Performance Optimization

  • Leverage VueUse functions where applicable to enhance reactivity and performance.
  • Wrap asynchronous components in Suspense with a fallback UI.
  • Use dynamic loading for non-critical components.
  • Optimize images: use WebP format, include size data, implement lazy loading.
  • Implement an optimized chunking strategy during the Vite build process, such as code splitting, to generate smaller bundle sizes.

Key Conventions

  • Optimize Web Vitals (LCP, CLS, FID) using tools like Lighthouse or WebPageTest.
  • Use the VueUse library for performance-enhancing functions.
  • Implement lazy loading for non-critical components.
  • Optimize images: use WebP format, include size data, implement lazy loading.
  • Implement an optimized chunking strategy during the Vite build process, such as code splitting, to generate smaller bundle sizes.

Code Review

  • Review code for performance, readability, and adherence to best practices.
  • Ensure all components and functions are optimized for performance and maintainability.
  • Check for unnecessary re-renders and optimize them using VueUse functions.
  • Use the VueUse library for performance-enhancing functions.
  • Implement lazy loading for non-critical components.
  • Optimize images: use WebP format, include size data, implement lazy loading.
  • Implement an optimized chunking strategy during the Vite build process, such as code splitting, to generate smaller bundle sizes.

Best Practices

  • Use the VueUse library for performance-enhancing functions.
  • Implement lazy loading for non-critical components.
  • Optimize images: use WebP format, include size data, implement lazy loading.
  • Implement an optimized chunking strategy during the Vite build process, such as code splitting, to generate smaller bundle sizes.

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