Style & Conventions rules

Check if private or `file`-scoped classes that are never inherited are explicitly marked as `sealed` to indicate they are final.

Check if properties that are never reassigned are marked as readonly. This improves code clarity and prevents unintended reassignment.

Elements with multiple attributes should span multiple lines, with one attribute per line.

Ensure that multiple variables are not declared in a single statement. This practice reduces readability and can introduce subtle bugs. Recommend declaring variables separately.

Component names should start with the highest-level (often most general) words and end with descriptive modifying words.

Check if class members are grouped by accessibility (`public`, `protected`, `private`) to improve code readability and maintainability.

Prefer data providers for parameterized cases and use assertSame/assertNotSame for type-strict checks; avoid loose equals.

Ensure that multiple statements are not written on the same line. Each statement should be placed on a new line to improve readability.

Use `const` for all references by default within Vue components (e.g., imports, non-reassigned variables, refs obtained via `ref()`). Use `let` only when reassignment of the variable itself is necessary (rare for state). Avoid `var` entirely.

Ensure that non-boolean properties or variables are titled with noun phrases (e.g., `userDetails`, not `getUserDetails`). This improves readability.

Use arrow functions (`=>`) for anonymous functions like callbacks (e.g., in lifecycle hooks, watchers, event handlers, array methods) instead of the `function` keyword, especially when needing lexical `this`.

Detect string formatting using `.format()` or `%`. These methods are less readable and slower than f-strings. Recommend converting string formatting to f-strings for better readability and performance.

Check if type aliases are used instead of interfaces. Interfaces provide better extensibility and readability when defining object shapes.

Ensure that titled classes are used instead of untitled tuples for complex data structures. Tuples should only be used when their purpose is immediately clear.

Use strict comparison operators (=== and !==) instead of loose (== and !=) in most cases. Strict comparisons check both type and value, avoiding PHP’s implicit type coercion pitfalls.

Prop names should always use camelCase during declaration. When used inside in-DOM templates, props should be kebab-cased. Single-File Components templates and JSX can use either kebab-case or camelCase props. Casing should be consistent.

Non-empty HTML attribute values should always be inside quotes (single or double, whichever is not used in JS).

Avoid `!` when nullability is already proven or a safer alternative (`??`, early return) exists.

Detect lines with trailing whitespace. Trailing spaces add unnecessary noise to version control diffs. Recommend removing them to keep the codebase clean.

Delete imports that are not referenced by the compilation unit.

Delete imports and locals that are not referenced; prefer tooling (ruff/flake8/mypy) to enforce.

Delete unused locals or prefix with underscore when required by interface.

Function names must describe side effects and return values (e.g., fetchUser vs. process).

Prefer named def functions for non-trivial logic; keep lambdas only for tiny, inline expressions.