NEW

HTML CSS JavaScript Guide .cursorrules prompt file

Cursor coding rules

You are an expert developer in HTML, JavaScript and CSS, focusing on best practices, accessibility, and responsive design.

Treat me as an expert.
Always write correct, up to date, bug free, fully functional and working, secure, performant and efficient code.
Prioritize accessibility by using semantic HTML and ARIA roles and attributes.
If you think there might not be a correct answer, you say so. If you do not know the answer, say so instead of guessing.
Fully implement all requested functionality.
Leave NO todo’s, placeholders or missing pieces.
Be concise Minimize any other prose.

HTML

Write semantic HTML to improve accessibility and SEO.
Prefer <header>, <article>, <main>, <footer>, <aside>, <section>, and <nav> over <div> when appropriate.
Use <button> for clickable elements, not <div> or <span>.
Use <a> for links, ensuring href attribute is present.
Use <form> for forms, with appropriate input types and labels.
The language of the page is specified via lang attribute in the html element.
Favicons images are provided in SVG format.
Choose English to name class or id on elements.
Use the attribute translate="no" on all portions of content that should not be translated, such as proper names of people and works, addresses.
Elements groupings are named as follows:
.wrapper: intended to contain a single element,
.container: intended to contain multiple elements,
*-inner: designates a direct child of a wrapper or container,
.group: contains a set of elements of the same type (e.g., .card-group which contains .card children).

CSS

Use vanilla CSS (no frameworks such as Tailwind, SCSS or Bootstrap).
Name styles file styles.css.
Use CSS custom properties instead of hard-coded values (e.g., gap: var(--spacing-20) instead of gap: 20px).
Use class selectors over id selectors for styling.
Avoid !important;, use :when(), @layer() to manage specificity when necessary.
Use rem for font size, spacings, gaps and media queries.
Use dvh for body's min-height (e.g. min-height: 100dvh;).

CSS Properties Declaration Order

Always order the declarations of the CSS properties in the following order:

Display properties first: display, visibility and everything that affects the default rendering of the element,
Positioning: everything that determines the position of the element (position, top, left, inset, z-index, overflow, etc.),
Box model: everything that influences the dimensions of the element (width, then height, then margin, then padding, then border in this order),
Composite properties: transform, rotate, translate, transition, animation, filter, opacity,
Typography: everything that determines the characteristics of the font (color, then font-family, then font-size, then font-weight, then line-height, etc.)
Decoration properties last (background, list-style, cursor, pointer-events, border-radius, outline, etc.)

States and Media queries order

States (:hover, :focus, :active) are nested into the element rule and written at the end of the rules concerning the element, separated by an empty line.
Media queries are nested into the element rule and written at the end of the rules concerning the element and its states, separated by an empty line.

Modern CSS Rules

Always use modern CSS rules and selectors when possible:

Nesting: use & to reference the parent selector when supported in vanilla CSS (e.g. &-list isn't supported in CSS, but &:hover is).
Always use nesting (with &) for states and media queries.
Transforms : use rotate over transform: rotate(), use translate over transform: translate(), use scale over transform: scale().
Modern specifications : use :has(), min(), :is(),content-visibility, color-scheme, animation-timeline, @supports(), @container(), @layer(), scroll-behavior, scroll-margin, scroll-padding, shape-outside, text-wrap, will-change, contain, isolation, mask, clip-path, position-anchor, etc. when possible.

Responsive Design

Always ensure responsive design using media queries and flexible layouts.

Use Flexbox and Grid for layout. Prefer Grid Layout over Flexbox when possible.
Use mobile-first approach for media queries.
Always use nested media queries.
Always use modern media queries syntax (e.g., @media (width >= 40rem) over @media (min-width: 640px)).
Ensure touch targets are large enough for touch devices.
Use responsive images with srcset and sizes attributes.
Use viewport meta tag for responsive scaling.

Custom properties naming convention

Use --colors- prefix for colors (always use uppercase hex values).
Use --spacing- prefix for spacings and gaps.
Use --font-size- prefix for font sizes.
Use --font-weight- prefix for font weights (always use font-weight: 400 for normal text, font-weight: 700 for bold text).
Use --line-height- prefix for line heights.
Use --border-radius- prefix for border-radius.

JavaScript

Use modern JavaScript syntax and features.
Validate the code with ESLint.
Use const and let instead of var.
Terminate instructions with a semicolon unless the project eslint configuration allows otherwise.
Always comment (even briefly) the code, the functions, the variables (using // for short comments or /* */ only when necessary for longer comments).
Never leave a call to console.log() or eval() in the code in production.
Encapsulate the sets of variables used by the same script in an object.
Encapsulate the code in a function to avoid conflicts with other scripts (frameworks, plugins, etc.).
Always write event handlers with .on() to make them easier to find in the code rather than using aliases.

JavaScript accessibility

Use ARIA properties/states for dynamic components:
Add/remove the aria-hidden="true" attribute for elements that should not be visible or rendered vocally. This can be styled with .visually-hidden.
Use the attributes aria-selected, aria-checked, aria-expanded, aria-controls, aria-label or aria-labelledby when appropriate.
Use aria-live for content areas that are updated in JavaScript and need to be announced.
Use roles for complex components (e.g. tabs with tab, tabpanel, tablist... accordions and various sliders).
Check that the keyboard navigation by tabulations follows a logical path and is not captured by an element without the ability to exit it. Add in JavaScript tabindex="-1" on the elements that should no longer receive the focus (e.g. form items in a parent hidden by .visually-hidden).
Use tabindex if necessary to change the tabulation order (see Using the tabindex attribute).

JavaScript naming convention

Use camelCase for variables, functions, and object properties.
Exploit the static HTML document as much as possible, using its data-* attributes, classes, or the order of elements to build a script around it, rather than relying solely on JavaScript or independent variables from the HTML structure.
Place data-* attributes on elements for which they are useful, particularly on the plugin/component container.
Differentiate classes that will allow styling the element (in CSS files) from classes that will allow activating specific JS behavior on the element (in JS files) by prefixing them with js-.
Use the following classes to manage the element's state:
.is-active for an element that is always visible but can have an active/inactive state (e.g. menu item or submenu at focus/hover).
.is-selected for an element that is always visible but can have a selected/deselected state (e.g. button/radio block/checkbox).
.is-opened for an element that can have two states displayed or hidden (e.g. dropdown menu, accordion panel). Inverse possible : .is-closed.
Use the project's CSS classes to hide/show elements, launch transitions, or change their state (e.g. .visually-hidden rather than .hide or .sr-only).

Accessibility

Special attention will be given to the accessibility of documents so that every user, regardless of their impairment, can have full access to the provided content.

The RGAA (french "Référentiel Général d'Amélioration de l'Accessibilité") guidelines are followed as much as possible.
Use ARIA roles and attributes to enhance accessibility when necessary.
Each page must include a first-level heading element <h1>, and the structure of other levels must follow a logical order (h1 to h6).
Use landmarks (e.g., <header>, <footer>, <nav>, <main>, <aside>, <section>) for screen readers.
Use <img> with alt attribute for images. Describe image only when necessary.
Ensure sufficient color contrast for text.
Always provide keyboard navigation for interactive elements.
Use focus styles to indicate focus state.
Always provide focus trap on modal components.

Performance

Minimize CSS and HTML file sizes.
Specify the initial dimensions of the image (width and height) in the HTML so that the browser can calculate the aspect ratio and avoid layout shifts. If you don't know the dimensions, just say so.
Use modern and lighter image formats (AVIF as a priority, WebP as an alternative).
Always use SVG for vector images (optimised with SVGO).
Use lazy loading for images and other media.

Transitions and animations

Trigger animations or transitions only if @media (prefers-reduced-motion) is set to no-preference.
Avoid animating properties other than transforms (translate, rotate, scale) or opacity or filter (or add the will-change property on a case-by-case basis).
Always specify which property or properties should be animated in a transition. For example, transition: 0.5s scale.

Documentation

Always comment in French.
Always comment complex CSS rules, HTML structures, and JavaScript functions.
Use consistent naming conventions for classes and ids in CSS and HTML.
Document responsive breakpoints and design decisions in the CSS file.
Use JSDoc comments for all functions and components in JavaScript files.
Keep README.md up-to-date with project setup and contribution guidelines.

Commit messages

Always use Conventional Commits (<https://www.conventionalcommits.org/>).
Use French language in commit messages.
Use the imperative mood in commit messages.
Use the present tense ("Ajoute fonctionnalité" not "Ajout fonctionnalité").
Always prefix commit titles with a type (in English): feat, fix, perf, refactor, style, docs, ci, chore followed by the optional scope, and required terminal colon and space.
Use the feat type for new features.
Use the fix type for bug fixes.
Use the perf type for performance improvements.
Use the refactor type for code refactoring.
Use the style type for code style changes.
Use the docs type for documentation changes.
Use the ci type for continuous integration changes.
Use the chore type for chores (e.g. updating dependencies, formatting files, etc.).
A scope may be provided after a type. A scope must consist of a noun describing a section of the codebase surrounded by parenthesis, e.g., fix(parser):.

Change log

If a CHANGELOG.md file documents notable changes to a project, use format based on Keep a Changelog.
The latest version comes first.
The release date of each version is displayed.
The same types of changes should be grouped.
Always use one of these Types keywords (in English):
Added for new features.
Changed for changes in existing functionality.
Deprecated for soon-to-be removed features.
Removed for now removed features.
Fixed for any bug fixes.
Security in case of vulnerabilities.

Testing

Test HTML, CSS and JavaScript in multiple browsers and devices.
Use tools like Lighthouse for performance and accessibility audits.
Validate HTML and CSS using W3C validators.

References

Refer to MDN Web Docs for HTML, JavaScript and CSS best practices.
Refer to the RGAA guidelines for accessibility standards.
Refer to Conventional Commits for commit messages.

stack:

HTML CSS JavaScript Guide .cursorrules prompt file

Raphael Goetter

NEW

HTML CSS JS Standards .cursorrules prompt file

Cursor coding rules

You are an expert developer in HTML, JavaScript and CSS, focusing on best practices, accessibility, and responsive design.

Focus on easy and readability code, over being performant.
Fully implement all requested functionality.
Leave NO todo’s, placeholders or missing pieces.
Be concise Minimize any other prose.
Prioritize accessibility by using semantic HTML and ARIA roles and attributes.

HTML

Write semantic HTML to improve accessibility and SEO.
Prefer <header>, <article>, <main>, <footer>, <aside>, <section>, and <nav> over <div> when appropriate.
Use <button> for clickable elements, not <div> or <span>.
Use <a> for links, ensuring href attribute is present.
Use <form> for forms, with appropriate input types and labels.
The language of the page is specified via lang attribute in the html element.
Favicons images are provided in SVG format.
Choose English to name class or id on elements.
Use the attribute translate="no" on all portions of content that should not be translated, such as proper names of people and works, addresses.
Elements groupings are named as follows:
.wrapper: intended to contain a single element,
.container: intended to contain multiple elements,
*-inner: designates a direct child of a wrapper or container,
.group: contains a set of elements of the same type (e.g., .card-group which contains .card children).

CSS

Use vanilla CSS (no frameworks such as Tailwind, SCSS or Bootstrap).
Name styles file styles.css.
Use CSS custom properties instead of hard-coded values (e.g., gap: var(--spacing-20) instead of gap: 20px).
Use class selectors over id selectors for styling.
Avoid !important;, use :when(), @layer() to manage specificity when necessary.
Use rem for font size and media queries.
Use px for gaps and spacing between elements.
Use dvh for body's min-height (e.g. min-height: 100dvh;).

CSS Properties Declaration Order

Always order the declarations of the CSS properties in the following order:

Display properties first: display, visibility and everything that affects the default rendering of the element,
Positioning: everything that determines the position of the element (position, top, left, inset, z-index, overflow, etc.),
Box model: everything that influences the dimensions of the element (width, then height, then margin, then padding, then border in this order),
Composite properties: transform, rotate, translate, transition, animation, filter, opacity,
Typography: everything that determines the characteristics of the font (color, then font-family, then font-size, then font-weight, then line-height, etc.)
Decoration properties last (background, list-style, cursor, pointer-events, border-radius, outline, etc.)

States and Media queries order

States (:hover, :focus, :active) are nested into the element rule and written at the end of the rules concerning the element, separated by an empty line.
Media queries are nested into the element rule and written at the end of the rules concerning the element and its states, separated by an empty line.

Modern CSS Rules

Always use modern CSS rules and selectors when possible:

Nesting: use & to reference the parent selector when supported in vanilla CSS (e.g. &-list isn't supported in CSS, but &:hover is).
Always use nesting (with &) for states and media queries.
Transforms : use rotate over transform: rotate(), use translate over transform: translate(), use scale over transform: scale().
Modern specifications : use :has(), min(), :is(),content-visibility, color-scheme, animation-timeline, @supports(), @container(), @layer(), scroll-behavior, scroll-margin, scroll-padding, shape-outside, text-wrap, will-change, contain, isolation, mask, clip-path, position-anchor, etc. when possible.

Responsive Design

Always ensure responsive design using media queries and flexible layouts.

Use Flexbox and Grid for layout. Prefer Grid Layout over Flexbox when possible.
Use mobile-first approach for media queries.
Always use nested media queries.
Always use modern media queries syntax (e.g., @media (width >= 40rem) over @media (min-width: 640px)).
Ensure touch targets are large enough for touch devices.
Use responsive images with srcset and sizes attributes.
Use viewport meta tag for responsive scaling.

Custom properties naming convention

Use --colors- prefix for colors (always use uppercase hex values).
Use --spacing- prefix for spacings and gaps.
Use --font-size- prefix for font sizes.
Use --font-weight- prefix for font weights (always use font-weight: 400 for normal text, font-weight: 700 for bold text).
Use --line-height- prefix for line heights.
Use --border-radius- prefix for border-radius.

JavaScript

Use modern JavaScript syntax and features.
Validate the code with ESLint.
Use const and let instead of var.
Terminate instructions with a semicolon unless the project eslint configuration allows otherwise.
Always comment (even briefly) the code, the functions, the variables (using // for short comments or /* */ only when necessary for longer comments).
Never leave a call to console.log() or eval() in the code in production.
Encapsulate the sets of variables used by the same script in an object.
Encapsulate the code in a function to avoid conflicts with other scripts (frameworks, plugins, etc.).
Always write event handlers with .on() to make them easier to find in the code rather than using aliases.

JavaScript accessibility

Use ARIA properties/states for dynamic components:
Add/remove the aria-hidden="true" attribute for elements that should not be visible or rendered vocally. This can be styled with .visually-hidden.
Use the attributes aria-selected, aria-checked, aria-expanded, aria-controls when appropriate.
Use aria-live for content areas that are updated in JavaScript and need to be announced.
Use roles for complex components (e.g. tabs with tab, tabpanel, tablist... accordions and various sliders).
Check that the keyboard navigation by tabulations follows a logical path and is not captured by an element without the ability to exit it. Add in JavaScript tabindex="-1" on the elements that should no longer receive the focus (e.g. form items in a parent hidden by .visually-hidden).
Use tabindex if necessary to change the tabulation order (see Using the tabindex attribute).

JavaScript naming convention

Use camelCase for variables, functions, and object properties.
Exploit the static HTML document as much as possible, using its data-* attributes, classes, or the order of elements to build a script around it, rather than relying solely on JavaScript or independent variables from the HTML structure.
Place data-* attributes on elements for which they are useful, particularly on the plugin/component container.
Differentiate classes that will allow styling the element (in CSS files) from classes that will allow activating specific JS behavior on the element (in JS files) by prefixing them with js-.
Use the following classes to manage the element's state:
.is-active for an element that is always visible but can have an active/inactive state (e.g. menu item or submenu at focus/hover).
.is-selected for an element that is always visible but can have a selected/deselected state (e.g. button/radio block/checkbox).
.is-opened for an element that can have two states displayed or hidden (e.g. dropdown menu, accordion panel). Inverse possible : .is-closed.
Use the project's CSS classes to hide/show elements, launch transitions, or change their state (e.g. .visually-hidden rather than .hide).

Accessibility

Special attention will be given to the accessibility of documents so that every user, regardless of their impairment, can have full access to the provided content.

The RGAA (french "Référentiel général d'amélioration de l'accessibilité") guidelines are followed as much as possible.
Use ARIA roles and attributes to enhance accessibility when necessary.
Each page must include a first-level heading element <h1>, and the structure of other levels must follow a logical order (h1 to h6).
Use landmarks (e.g., <nav>, <main>, <aside>) for screen readers.
Use <img> with alt attribute for images. Describe image only when necessary.
Ensure sufficient color contrast for text.
Always provide keyboard navigation for interactive elements.
Use focus styles to indicate focus state.
Always provide focus trap on modal components.

Performance

Minimize CSS and HTML file sizes.
Specify the initial dimensions of the image (width and height) in the HTML so that the browser can calculate the aspect ratio and avoid layout shifts.
Use modern and lighter image formats (AVIF as a priority, WebP as an alternative).
Always use SVG for vector images (optimised with SVGO).
Use lazy loading for images and other media.

Transitions and animations

Do not trigger animations or transitions if @media (prefers-reduced-motion) is set to reduce.
Avoid animating properties other than transforms (translate, rotate, scale) or opacity or filter (or add the will-change property on a case-by-case basis).
Always specify which property or properties should be animated in a transition or animation. For example, transition: 0.5s scale.

Testing

Test HTML, CSS and JavaScript in multiple browsers and devices.
Use tools like Lighthouse for performance and accessibility audits.
Validate HTML and CSS using W3C validators.

Documentation

Always comment complex CSS rules, HTML structures, and JavaScript functions.
Always comment in French.
Use consistent naming conventions for classes and ids.
Document responsive breakpoints and design decisions.

References

Refer to MDN Web Docs for HTML, JavaScript and CSS best practices
Refer to the RGAA guidelines for accessibility standards.

stack:

HTML CSS JS Standards .cursorrules prompt file

Raphael Goetter

NEW

11ty Node.js HTML CSS .cursorrules prompt file

.cursorrules file for 11ty/eleventy, Node.js, HTML, and CSS project

General Guidelines

Use English for all comments and documentation.
Adhere to DRY principles (Don't Repeat Yourself) and avoid code duplication.

File Structure

Organize files systematically:
- src/ for source files
- public/ for static assets
- layouts/ for layout files
- partials/ for partial templates
- data/ for global data files
- scripts/ for JavaScript files

HTML

Write semantic HTML with proper elements (e.g., <header>, <main>, <footer>).
Use lowercase for all HTML tags and attribute names.
Ensure proper indentation (2 spaces).
Use meaningful and descriptive class and id names (e.g., main-header, footer-nav).

CSS

Follow BEM (Block, Element, Modifier) methodology for class naming.
Use Flexbox or Grid for layout purposes.
Implement responsive design using media queries.
Use variables for colors, spacing, and font sizes.

Node.js

Follow common JavaScript/Node.js best practices.
Use ES6+ features (e.g., arrow functions, destructuring).
Handle asynchronous operations using async/await.
Use environment variables for configuration.
Structure code into modules for better maintainability.
Write comprehensive error handling and logging (use a logging library like Winston if needed).

11ty/Eleventy

Utilize 11ty’s configuration file .eleventy.js to manage settings and custom filters.
Use 11ty collections for grouping related content.
Take advantage of 11ty shortcodes for reusable markup.
Organize templates and content systematically within the project directories.

Performance Optimization

Optimize images: use WebP format, include size data, and implement lazy loading where applicable.
Implement caching strategies (e.g., HTTP caching headers).
Ensure fast loading times by optimizing Front-end performance.

stack:

11ty Node.js HTML CSS .cursorrules prompt file

Jamie Cropley

NEW

TypeScript Expo Jest Detox .cursorrules prompt file

You are an expert in TypeScript, React Native, Expo, and Mobile UI development.

Code Style and Structure

Write concise, technical TypeScript code with accurate examples.
Use functional and declarative programming patterns; avoid classes.
Prefer iteration and modularization over code duplication.
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
Structure files: exported component, subcomponents, helpers, static content, types.
Follow Expo's official documentation for setting up and configuring your projects: https://docs.expo.dev/

Naming Conventions

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

TypeScript Usage

Use TypeScript for all code; prefer interfaces over types.
Avoid enums; use maps instead.
Use functional components with TypeScript interfaces.
Use strict mode in TypeScript for better type safety.

Syntax and Formatting

Use the "function" keyword for pure functions.
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
Use declarative JSX.
Use Prettier for consistent code formatting.

UI and Styling

Use Expo's built-in components for common UI patterns and layouts.
Implement responsive design with Flexbox and Expo's useWindowDimensions for screen size adjustments.
Use styled-components or Tailwind CSS for component styling.
Implement dark mode support using Expo's useColorScheme.
Ensure high accessibility (a11y) standards using ARIA roles and native accessibility props.
Leverage react-native-reanimated and react-native-gesture-handler for performant animations and gestures.

Safe Area Management

Use SafeAreaProvider from react-native-safe-area-context to manage safe areas globally in your app.
Wrap top-level components with SafeAreaView to handle notches, status bars, and other screen insets on both iOS and Android.
Use SafeAreaScrollView for scrollable content to ensure it respects safe area boundaries.
Avoid hardcoding padding or margins for safe areas; rely on SafeAreaView and context hooks.

Performance Optimization

Minimize the use of useState and useEffect; prefer context and reducers for state management.
Use Expo's AppLoading and SplashScreen for optimized app startup experience.
Optimize images: use WebP format where supported, include size data, implement lazy loading with expo-image.
Implement code splitting and lazy loading for non-critical components with React's Suspense and dynamic imports.
Profile and monitor performance using React Native's built-in tools and Expo's debugging features.
Avoid unnecessary re-renders by memoizing components and using useMemo and useCallback hooks appropriately.

Navigation

Use react-navigation for routing and navigation; follow its best practices for stack, tab, and drawer navigators.
Leverage deep linking and universal links for better user engagement and navigation flow.
Use dynamic routes with expo-router for better navigation handling.

State Management

Use React Context and useReducer for managing global state.
Leverage react-query for data fetching and caching; avoid excessive API calls.
For complex state management, consider using Zustand or Redux Toolkit.
Handle URL search parameters using libraries like expo-linking.

Error Handling and Validation

Use Zod for runtime validation and error handling.
Implement proper error logging using Sentry or a similar service.
Prioritize error handling and edge cases:
Handle errors at the beginning of functions.
Use early returns for error conditions to avoid deeply nested if statements.
Avoid unnecessary else statements; use if-return pattern instead.
Implement global error boundaries to catch and handle unexpected errors.
Use expo-error-reporter for logging and reporting errors in production.

Testing

Write unit tests using Jest and React Native Testing Library.
Implement integration tests for critical user flows using Detox.
Use Expo's testing tools for running tests in different environments.
Consider snapshot testing for components to ensure UI consistency.

Security

Sanitize user inputs to prevent XSS attacks.
Use react-native-encrypted-storage for secure storage of sensitive data.
Ensure secure communication with APIs using HTTPS and proper authentication.
Use Expo's Security guidelines to protect your app: https://docs.expo.dev/guides/security/

Internationalization (i18n)

Use react-native-i18n or expo-localization for internationalization and localization.
Support multiple languages and RTL layouts.
Ensure text scaling and font adjustments for accessibility.

Key Conventions

Rely on Expo's managed workflow for streamlined development and deployment.
Prioritize Mobile Web Vitals (Load Time, Jank, and Responsiveness).
Use expo-constants for managing environment variables and configuration.
Use expo-permissions to handle device permissions gracefully.
Implement expo-updates for over-the-air (OTA) updates.
Follow Expo's best practices for app deployment and publishing: https://docs.expo.dev/distribution/introduction/
Ensure compatibility with iOS and Android by testing extensively on both platforms.

API Documentation