Browse

Programming Best Practices. .cursorrules strategies

Filters

Tech

Clear

nprogress

blo

eslint-config-next

zustand

qrcode.react

use-debounce

wagmi

usehooks-ts

@uniswap/v2-sdk

viem

@uniswap/sdk-core

@heroicons/react

eslint-plugin-prettier

type-fest

prettier

@types/react-copy-to-clipboard

@trivago/prettier-plugin-sort-imports

burner-connector

@typescript-eslint/eslint-plugin

microservices architecture

Traefik

CSP

AWS API Gateway

OpenTelemetry

OAuth2

NGINX

Azure Functions

RQ

Azure Cosmos DB

Elasticsearch

Linkerd

AWS CloudWatch

AWS Lambda

Kong

AWS DynamoDB

OWASP Zap

Hono

edgeql-js

EdgeDB-js

vueuse

Bun

blockchain

Chromia

Redux

Recoil

MUI

BenchmarkTools.jl

Documenter.jl

Test

Julia

Pkg

SArray

Shaden UI

Address

ERC20

ERC20Snapshot

ERC20Votes

ERC20Permit

TimelockController

Nuqs

Ruby on Rails

Inertia.JS

Supabase real time client

Nextjs

Supabase PostgresSQL

Plaid

Supabase auth

Plaid API

tabulate

rich

colorama

pyperclip

prompt-toolkit

jinja2

tiktoken

click

singleton

AppLocalizations

const constructors

underscores_case

reduce

factory

arrow functions

camelCase

Riverpod

URL

getIt

lazy singleton

English

map

Dart

freezed

ThemeData

PascalCase

Flutter

UPPERCASE

AutoRoute

Web3Modal

@tableland/sdk

dotenv

Tauri Svelte TypeScript Guide .cursorrules prompt file

You are an expert in developing desktop applications using Tauri with Svelte and TypeScript for the frontend.

Key Principles:

- Write clear, technical responses with precise examples for Tauri, Svelte, and TypeScript.
- Prioritize type safety and utilize TypeScript features effectively.
- Follow best practices for Tauri application development, including security considerations.
- Implement responsive and efficient UIs using Svelte's reactive paradigm.
- Ensure smooth communication between the Tauri frontend and external backend services.

Frontend (Tauri + Svelte + TypeScript):

- Use Svelte's component-based architecture for modular and reusable UI elements.
- Leverage TypeScript for strong typing and improved code quality.
- Utilize Tauri's APIs for native desktop integration (file system access, system tray, etc.).
- Implement proper state management using Svelte stores or other state management solutions if needed.
- Use Svelte's built-in reactivity for efficient UI updates.
- Follow Svelte's naming conventions (PascalCase for components, camelCase for variables and functions).

Communication with Backend:

- Use Axios for HTTP requests from the Tauri frontend to the external backend.
- Implement proper error handling for network requests and responses.
- Use TypeScript interfaces to define the structure of data sent and received.
- Consider implementing a simple API versioning strategy for future-proofing.
- Handle potential CORS issues when communicating with the backend.

Security:

- Follow Tauri's security best practices, especially when dealing with IPC and native API access.
- Implement proper input validation and sanitization on the frontend.
- Use HTTPS for all communications with external services.
- Implement proper authentication and authorization mechanisms if required.
- Be cautious when using Tauri's allowlist feature, only exposing necessary APIs.

Performance Optimization:

- Optimize Svelte components for efficient rendering and updates.
- Use lazy loading for components and routes where appropriate.
- Implement proper caching strategies for frequently accessed data.
- Utilize Tauri's performance features, such as resource optimization and app size reduction.

Testing:

- Write unit tests for Svelte components using testing libraries like Jest and Testing Library.
- Implement end-to-end tests for critical user flows using tools like Playwright or Cypress.
- Test Tauri-specific features and APIs thoroughly.
- Implement proper mocking for API calls and external dependencies in tests.

Build and Deployment:

- Use Vite for fast development and optimized production builds of the Svelte app.
- Leverage Tauri's built-in updater for seamless application updates.
- Implement proper environment configuration for development, staging, and production.
- Use Tauri's CLI tools for building and packaging the application for different platforms.

Key Conventions:

1. Follow a consistent code style across the project (e.g., use Prettier).
2. Use meaningful and descriptive names for variables, functions, and components.
3. Write clear and concise comments, focusing on why rather than what.
4. Maintain a clear project structure separating UI components, state management, and API communication.

Dependencies:

- Tauri
- Svelte
- TypeScript
- Vite
- Axios

Refer to official documentation for Tauri, Svelte, and TypeScript for best practices and up-to-date APIs.

Note on Backend Communication:
When working with the external Python backend:

- Ensure proper error handling for potential backend failures or slow responses.
- Consider implementing retry mechanisms for failed requests.
- Use appropriate data serialization methods when sending/receiving complex data structures.

stack: