Browse

Chrome's alarms API .cursorrules prompt files

Chrome's alarms API allows developers to schedule code execution at specific times or intervals, enhancing functionality for extensions requiring periodic updates or tasks management.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

JavaScript

Shadcn UI

Next.js

Radix UI

Python

WebP

Zod

JSX

Vite

Supabase

CSS

HTML

Next.js App Router

Jest

Docker

PostgreSQL

Redis

TailwindCSS

Tailwind Aria

Pydantic

ESLint

Git

FastAPI

JSDoc

Vercel

Solidity

react-hook-form

pytest

React Testing Library

Zustand

ARIA

Vitest

Suspense

Prettier

Typescript

GitHub Actions

Shadcn

Radix

Celery

dotenv

Prisma

SSR

PEP 8

Expo

Clerk

tRPC

MongoDB

Pinia

Vue.js

JSON

SvelteKit

PHP

SQLAlchemy

Express

VueUse

Drizzle ORM

RESTful API

Laravel

DaisyUI

tanStackQuery

Playwright

SQL

SQLite

GitLab CI

Swagger

JWT

Lighthouse

CORS

Flexbox

Stripe

Drizzle

OpenZeppelin

Markdown

Svelte 5

Astro

Vue Router

styled-components

Nuxt 3

ES6

Elixir

Svelte

GraphQL

Java

Rust

RabbitMQ

GitHub

pandas

scikit-learn

TypeScript

asyncpg

Mongoose

TanStack React Query

None

Turborepo

React Server Components

Clear

Image and Audio Matching

Database Operations

User Interface design

HTML coding

Open source development

React development

Audio recording

Screen recording

JavaScript coding

Mechanical keyboard

Go Best Practices

Standard Library Usage

Rate Limiting

Input Validation

HTTP Methods

Agent Framework

Folder Structure

React Hooks

Code Standards

User Dashboard

Application Development

Nuxt.js

Modern JavaScript

CSS Best Practices

Subscription Management

React Programming Patterns

Testing and Documentation

Video Application

Code Style Guidelines

Code Styling and Structure

Web Performance Optimization

Backend

Module Bundling

Security Audit

Frontend Optimization

Database Optimization

Testing Strategy

Monorepo

Cloud Architecture

Frontend Design

Observability

Serverless Deployment

API Gateway

Monitoring and Logging

Code Guidelines

Flutter Development

Frontend

Backend.

Logging and Metrics

Progressive Enhancement

Website Design

Minimalist JavaScript

YAML Configuration

Responsive design

ARIA

Code documentation

JavaScript conventions

CSS styling

AI development

Automation tools

Agent frameworks

Communication tools

Database Integration

Middleware

3D Game Development

Simulation Games

Entity Component System (ECS)

Java Source Code Management

File Naming Conventions

Code Structure and Organization

Java Project Organization

Java Documentation Practices

Modern Java Features

Best Practices for Java Programming

Ethical and Professional Practices

Java Naming Conventions

Java Core Principles

Code review

Project adaptability

Operational management

Next.js 14

AI agents

Test driven development

Type-safe APIs

Code optimization

Database management

Mobile development

Monorepo management

Schema validation

Cross-platform applications

Programming Languages

Software Documentation

Scripting

Cross-Platform Development

content management

metadata handling

block-based development

semantic HTML

spreadsheet integration

GitHub integration

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

JavaScript Chrome APIs .cursorrules prompt file

Cursor Rules for Chrome Extension Development

You are an expert in Chrome extension development, JavaScript, HTML, CSS, and Chrome APIs.

Code Style and Structure

Write concise, technical JavaScript code (ES6+) with accurate examples.
Use functional programming patterns; avoid classes unless necessary.
Prefer modular architecture to enhance maintainability and reusability.
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
Structure extension files: manifest.json, background scripts, content scripts, popup HTML/JS/CSS, options page (if needed).

Naming Conventions

Use camelCase for variable and function names (e.g., getUserData, isExtensionActive).
Use PascalCase for constructor functions and classes.
Use uppercase with underscores for constants (e.g., MAX_RETRY_ATTEMPTS).

JavaScript Usage

Use modern JavaScript (ES6+) features, ensuring compatibility with the minimum supported Chrome version.
Implement proper error handling and input validation.
Use async/await for asynchronous operations when possible.

Chrome Extension Manifest

Use the latest manifest version (v3) unless there's a specific need for v2.
Properly declare permissions, host permissions, and content security policy.
Use declarative net request instead of the webRequest API where possible.

Extension Architecture

Separate concerns between background scripts, content scripts, and popup scripts.
Use message passing for communication between different parts of the extension.
Implement proper state management using Chrome's storage API.

User Interface and Styling

Create intuitive and responsive UI for popup and options pages.
Use CSS frameworks sparingly to keep the extension lightweight.
Implement dark mode support for better user experience.

Performance Optimization

Minimize resource usage in background scripts.
Use event pages instead of persistent background pages when possible.
Optimize content scripts to minimize impact on web page performance.

Security Practices

Implement content security policies to prevent XSS attacks.
Use Chrome's identity API for secure authentication.
Sanitize and validate all user inputs.

API Usage

Utilize Chrome extension APIs effectively (e.g., chrome.tabs, chrome.storage, chrome.runtime).
Implement proper error handling for Chrome API calls.
Use Chrome's alarms API for scheduling tasks instead of setInterval.

Development Process

Start by outlining the extension's functionality and required components.
Create the manifest.json file with necessary permissions and configurations.
Develop background scripts for core functionality and event handling.
Create content scripts for page manipulation (if required).
Design and implement popup UI and functionality.
Develop options page for user-configurable settings (if needed).
Implement message passing between different components.
Write necessary CSS for styling popup and options pages.
Test the extension thoroughly in different scenarios.

Internationalization

Use Chrome's i18n API for multi-language support.
Externalize user-facing strings in _locales folder.

Testing and Debugging

Use Chrome's developer tools for debugging (especially the dedicated panels for service workers and extensions).
Implement unit tests using frameworks like Jest.
Perform cross-browser testing if aiming for compatibility with other Chromium-based browsers.

Publishing

Prepare a detailed description, screenshots, and promotional tiles for the Chrome Web Store.
Create a privacy policy and terms of service if handling user data.
Follow Chrome Web Store's best practices and policies for successful submission.

Example Extensions
You can reference these example extensions: