@sinemacula/coding-standards 1.9.2 → 1.11.0

package/README.md

@@ -121,13 +121,16 @@ typescript-eslint tooling, and this package to your dev dependencies:
 npm install --save-dev eslint typescript typescript-eslint eslint-plugin-jsdoc @sinemacula/coding-standards
 ```
 
-The package exposes two flat-config entry points:
+The package exposes three flat-config entry points:
 
 - `@sinemacula/coding-standards/js/eslint` - the base layer of syntax-only custom rules; needs no `tsconfig`, so it
   stays cheap and runs anywhere Biome runs.
 - `@sinemacula/coding-standards/js/eslint/type-checked` - the opt-in type-aware layer. It includes the base layer and
   adds the cross-file / type-driven rules, so it needs a consumer `tsconfig`; use it in place of the base layer where
   one exists.
+- `@sinemacula/coding-standards/js/eslint/vue` - the opt-in Vue layer for single-file components. Unlike the
+  type-aware layer it carries no base rules of its own, so spread it *alongside* whichever layer the repository
+  already uses rather than in place of one.
 
 Create an `eslint.config.js` (or `.qlty/configs/eslint.config.js` when wired through Qlty) that spreads the layer you
 want. Without a `tsconfig`, use the base layer:
@@ -146,6 +149,25 @@ import typeChecked from '@sinemacula/coding-standards/js/eslint/type-checked';
 export default [...typeChecked];
 ```
 
+Vue repositories add the Vue toolchain and spread the Vue layer after the layer they already use:
+
+```bash
+npm install --save-dev eslint-plugin-vue vue-eslint-parser eslint-plugin-check-file
+```
+
+```js
+import typeChecked from '@sinemacula/coding-standards/js/eslint/type-checked';
+import vue from '@sinemacula/coding-standards/js/eslint/vue';
+
+export default [...typeChecked, ...vue];
+```
+
+The Vue layer registers the single-file-component parser (without it `.vue` files are not linted at all), resolves
+`<script lang="ts">` blocks through the TypeScript parser, and holds component filenames to kebab-case. It also
+carries the template layout rules, which is the one place ESLint takes on formatting: Biome does not understand
+single-file components, so `.vue` markup would otherwise go unformatted entirely. Those rules are aligned to the
+shared four-space indent.
+
 When wiring ESLint through Qlty, the shared eslint plugin sandbox installs only `eslint`, `jest`, and `prettier` by
 default, so the flat config's imports of this package and `typescript-eslint` fail to resolve. Widen the install
 filter in your `.qlty/qlty.toml` so the sandbox carries them (this repository's `source.toml` exports the same
@@ -156,6 +178,17 @@ override, but source-exported plugin definitions do not reliably propagate, so m
 package_filters = ["@sinemacula/coding-standards", "typescript-eslint", "@typescript-eslint", "eslint-plugin-jsdoc"]
 ```
 
+Repositories enabling the Vue layer widen the same filter further, since its plugins have to resolve inside that
+sandbox too:
+
+```toml
+[plugins.definitions.eslint]
+package_filters = [
+    "@sinemacula/coding-standards", "typescript-eslint", "@typescript-eslint", "eslint-plugin-jsdoc",
+    "eslint-plugin-vue", "vue-eslint-parser", "eslint-plugin-check-file",
+]
+```
+
 ### Knip (JavaScript / TypeScript)
 
 ```json
@@ -187,7 +220,7 @@ tag = "<version>"
 | `php/phpstan-base.neon`       | PHPStan      | Base config (org-wide ignored errors + settings)       |
 | `js/biome.json`               | Biome        | JavaScript / TypeScript formatter + linter rules       |
 | `js/knip.json`                | Knip         | Unused-export detection rules                          |
-| `js/eslint/`                  | ESLint       | Custom structural + type-aware rules; runs with Biome  |
+| `js/eslint/`                  | ESLint       | Structural, type-aware + Vue rules; runs with Biome    |
 | `markdown/.markdownlint.json` | markdownlint | Markdown linting rules                                 |
 | `yaml/.yamllint.yaml`         | yamllint     | YAML linting rules                                     |
 | `shell/.shellcheckrc`         | ShellCheck   | Shell script linting rules                             |
@@ -249,14 +282,17 @@ type-checked layer.
 | `@sinemacula/max-methods-per-class` | A single class may declare at most 20 methods; test code exempt. |
 | `@sinemacula/no-base-error` | Throw a domain-specific `Error` subclass, never the base `Error`; test code exempt. |
 | `@sinemacula/require-copyright` | Every file must carry a documentation comment with `@copyright` and `@author`. |
+| `@sinemacula/align-doc-tags` | `@author` and `@copyright` values line up at a single column; autofixable. |
 
 `boolean-method-name` takes `additionalPrefixes`, `additionalPredicates` and `additionalCommandVerbs` (string arrays)
 to widen the accepted vocabulary from a consumer config. `max-methods-per-class` takes `max`, `no-base-error` takes
-`allow`, and `require-copyright` takes `tags` to adjust their defaults.
+`allow`, and `require-copyright` takes `tags` to adjust their defaults. `align-doc-tags` takes `tags` and `column`,
+the column counting from the `@`, so the default of 14 gives `@author` six spaces and `@copyright` three.
 
 The base layer also switches on a set of built-in rules: `@typescript-eslint/no-explicit-any`, `max-lines-per-function`
 (50 lines, test code exempt) and `max-depth` (4), plus `eslint-plugin-jsdoc` rules that require a documentation comment
-on every declared function, method and class and forbid types in `@param`/`@returns` (types belong in the signature).
+on every declared function, method and class, forbid types in `@param`/`@returns` (the tags themselves are welcome,
+types belong in the signature) and keep a blank line above every documentation block, single-line blocks included.
 The type-checked layer adds `@typescript-eslint/explicit-module-boundary-types` and
 `@typescript-eslint/only-throw-error`.
 

package/js/biome.json

@@ -60,6 +60,12 @@
                 "useConst": "warn",
                 "useDefaultParameterLast": "warn",
                 "useExponentiationOperator": "warn",
+                "useFilenamingConvention": {
+                    "level": "warn",
+                    "options": {
+                        "filenameCases": ["kebab-case"]
+                    }
+                },
                 "useNamingConvention": {
                     "level": "warn",
                     "options": {
@@ -98,7 +104,16 @@
         "enabled": true,
         "actions": {
             "source": {
-                "organizeImports": "on"
+                "organizeImports": {
+                    "level": "on",
+                    "options": {
+                        "groups": [
+                            [":BUN:", ":NODE:", ":PACKAGE_WITH_PROTOCOL:", ":URL:", ":PACKAGE:"],
+                            ":BLANK_LINE:",
+                            [":ALIAS:", ":PATH:"]
+                        ]
+                    }
+                }
             }
         }
     },

package/js/eslint/index.js

@@ -8,11 +8,11 @@ const TS_AND_JS_FILES = [...TS_FILES, '**/*.js', '**/*.jsx', '**/*.mjs', '**/*.c
 /**
  * Base flat config: the AST-only custom rules that need no type information.
  *
- * Requires no tsconfig, so it stays cheap. The typescript-eslint parser resolves
- * TypeScript syntax. The interface, readonly-property and enum rules target
- * TypeScript-only constructs; no-mutable-static also applies to plain JavaScript
- * (exported let/var, mutable static fields), so it runs across both. The opt-in
- * type-aware layer lives in ./type-checked.js.
+ * Requires no tsconfig, so it stays cheap. The typescript-eslint parser
+ * resolves TypeScript syntax. The interface, readonly-property and enum rules
+ * target TypeScript-only constructs; no-mutable-static also applies to plain
+ * JavaScript (exported let/var, mutable static fields), so it runs across both.
+ * The opt-in type-aware layer lives in ./type-checked.js.
  *
  * @author      Ben Carey <bdmc@sinemacula.co.uk>
  * @copyright   2026 Sine Macula Limited
@@ -49,13 +49,17 @@ export default [
             '@sinemacula/max-methods-per-class': 'error',
             '@sinemacula/no-base-error': 'error',
             '@sinemacula/require-copyright': 'error',
+            '@sinemacula/align-doc-tags': 'error',
 
             'max-lines-per-function': ['error', { max: 50, skipComments: true, skipBlankLines: true, IIFEs: true }],
             'max-depth': ['error', 4],
 
-            // Every declared function, method, class and assigned arrow carries a
-            // documentation comment describing intent; types live in the signature,
-            // never in the comment (no @param/@returns type tags).
+            // Every declared function, method, class and assigned arrow carries
+            // a documentation comment describing intent. Types live in the
+            // signature, so a tag never annotates one: the @param and @returns
+            // tags themselves are welcome, only their type forms are not. Each
+            // block stands off from the code above it, single-line blocks
+            // included.
             'jsdoc/require-jsdoc': ['error', {
                 require: {
                     ClassDeclaration: true,
@@ -73,6 +77,7 @@ export default [
             'jsdoc/no-types': 'error',
             'jsdoc/require-param-description': 'error',
             'jsdoc/require-returns-description': 'error',
+            'jsdoc/lines-before-block': ['error', { lines: 1, ignoreSingleLines: false }],
         },
     },
     {

package/js/eslint/plugin.js

@@ -1,3 +1,4 @@
+import alignDocTags from './rules/align-doc-tags.js';
 import booleanMethodName from './rules/boolean-method-name.js';
 import maxMethodsPerClass from './rules/max-methods-per-class.js';
 import noBaseError from './rules/no-base-error.js';
@@ -30,5 +31,6 @@ export default {
         'max-methods-per-class': maxMethodsPerClass,
         'no-base-error': noBaseError,
         'require-copyright': requireCopyright,
+        'align-doc-tags': alignDocTags,
     },
 };

package/js/eslint/rules/align-doc-tags.js

@@ -0,0 +1,125 @@
+import { createRule } from './lib.js';
+
+const DEFAULT_TAGS = ['author', 'copyright'];
+const DEFAULT_COLUMN = 14;
+
+/** A documentation line opening a tag that carries a value. */
+const TAG_LINE = /^(\s*\*\s*)@([A-Za-z][\w-]*)([^\S\n]+)(?=\S)/;
+
+/**
+ * The spaces that place a tag's value at the target column, or null when the
+ * tag is too long to reach it.
+ */
+function padding(tag, column) {
+    const spaces = column - tag.length - 2;
+
+    return spaces > 0 ? ' '.repeat(spaces) : null;
+}
+
+/**
+ * Align the values of the documentation tags a file's header declares,
+ * `@author` and `@copyright` by default.
+ *
+ * The tags a file must carry read as a block, so their values line up at a
+ * single column rather than sitting at whatever offset each tag's own length
+ * happens to produce. The column counts from the `@`, which at the default of
+ * 14 gives `@author` six spaces and `@copyright` three.
+ *
+ * Only the run of whitespace between a listed tag and its value is considered,
+ * and only on the line the tag opens; a wrapped value's continuation lines, a
+ * tag with no value and every unlisted tag are left alone. A tag longer than
+ * the column can accommodate is skipped rather than reported, as no spacing
+ * would satisfy the requirement. Presence of the tags is a separate concern,
+ * enforced by `require-copyright`.
+ *
+ * @author      Ben Carey <bdmc@sinemacula.co.uk>
+ * @copyright   2026 Sine Macula Limited
+ */
+export default createRule({
+    name: 'align-doc-tags',
+    meta: {
+        type: 'layout',
+        fixable: 'whitespace',
+        docs: {
+            description: 'Align the values of the documentation tags a file header declares.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    tags: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    column: {
+                        type: 'integer',
+                        minimum: 1,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            misaligned: 'The @{{ tag }} value must start at column {{ column }}.',
+        },
+    },
+    defaultOptions: [{ tags: DEFAULT_TAGS, column: DEFAULT_COLUMN }],
+    create(context, [options]) {
+        const { sourceCode } = context;
+        const tags = new Set((options.tags ?? DEFAULT_TAGS).map(tag => tag.toLowerCase()));
+        const column = options.column ?? DEFAULT_COLUMN;
+
+        /** Report and fix the spacing a single tag line carries. */
+        function inspect(line, start) {
+            const match = TAG_LINE.exec(line);
+
+            if (!match) {
+                return;
+            }
+
+            const [, prefix, tag, spacing] = match;
+
+            if (!tags.has(tag.toLowerCase())) {
+                return;
+            }
+
+            const desired = padding(tag, column);
+
+            if (desired === null || spacing === desired) {
+                return;
+            }
+
+            const from = start + prefix.length + 1 + tag.length;
+            const to = from + spacing.length;
+
+            context.report({
+                loc: {
+                    start: sourceCode.getLocFromIndex(from),
+                    end: sourceCode.getLocFromIndex(to),
+                },
+                messageId: 'misaligned',
+                data: { tag, column },
+                fix: fixer => fixer.replaceTextRange([from, to], desired),
+            });
+        }
+
+        return {
+            Program() {
+                for (const comment of sourceCode.getAllComments()) {
+                    if (comment.type !== 'Block' || !comment.value.startsWith('*')) {
+                        continue;
+                    }
+
+                    // The comment's value begins after the opening `/*`, so an
+                    // offset within it maps onto the source two characters in.
+                    let offset = comment.range[0] + 2;
+
+                    for (const line of comment.value.split('\n')) {
+                        inspect(line, offset);
+                        offset += line.length + 1;
+                    }
+                }
+            },
+        };
+    },
+});

package/js/eslint/rules/boolean-method-name.js

@@ -52,8 +52,9 @@ function isCommandVerb(name, verbs) {
 
 /**
  * Whether a return type resolves to boolean, ignoring a nullable `?bool`-style
- * null/undefined/void tail so an optional boolean still counts. Promise wrappers
- * are unwrapped before this is called, so an awaited boolean counts too.
+ * null/undefined/void tail so an optional boolean still counts. Promise
+ * wrappers are unwrapped before this is called, so an awaited boolean counts
+ * too.
  */
 function returnsBoolean(type) {
     if (type.flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) {
@@ -71,7 +72,9 @@ function returnsBoolean(type) {
     return false;
 }
 
-/** Whether the node is a function expression carrying an inspectable signature. */
+/**
+ * Whether the node is a function expression carrying an inspectable signature.
+ */
 function isFunctionExpression(node) {
     return node != null
         && (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression');
@@ -90,7 +93,9 @@ function keyName(keyNode) {
     return null;
 }
 
-/** Peel `as`/`satisfies`/non-null wrappers off an expression to reach the value. */
+/**
+ * Peel `as`/`satisfies`/non-null wrappers off an expression to reach the value.
+ */
 function unwrapExpression(node) {
     let current = node;
 
@@ -128,8 +133,8 @@ function hasImperativeTag(sourceCode, docHost, nameNode) {
 
 /**
  * Report the name when it neither reads as a predicate nor is exempt and the
- * resolved (awaited) return type is boolean. Type-predicate guards are predicates
- * by structure and left alone.
+ * resolved (awaited) return type is boolean. Type-predicate guards are
+ * predicates by structure and left alone.
  */
 function inspect(state, nameNode, name, fnNode, docHost) {
     const { checker, services, context, sourceCode } = state;
@@ -195,8 +200,9 @@ function inspectMember(state, node, allowEmptyBody) {
 }
 
 /**
- * The visitor: inspect each named function, method, signature and function-valued
- * member for a boolean return that does not read as a predicate.
+ * The visitor: inspect each named function, method, signature and
+ * function-valued member for a boolean return that does not read as a
+ * predicate.
  */
 function buildListeners(state) {
     return {
@@ -253,17 +259,19 @@ function buildListeners(state) {
  * Boolean method name rule.
  *
  * A function, method, arrow-bound class field, object method or interface/type
- * signature returning boolean should read as a predicate. A name is accepted when
- * its first camelCase word is a copular or modal prefix (is, has, can, ...), an
- * idiomatic predicate from ALLOWED_PREDICATES (e.g. successful), or a verb ending
- * in `s` (third-person: permits, passes) or `ed` (past tense: succeeded, failed,
- * expired). An imperative command verb (execute, persist, guard, ...) that returns
- * a result bool is exempt via COMMAND_VERBS. A member may also opt out with an
+ * signature returning boolean should read as a predicate. A name is accepted
+ * when its first camelCase word is a copular or modal prefix (is, has, can,
+ * ...), an idiomatic predicate from ALLOWED_PREDICATES (e.g. successful), or a
+ * verb ending in `s` (third-person: permits, passes) or `ed` (past tense:
+ * succeeded, failed, expired). An imperative command verb (execute, persist,
+ * guard, ...) that returns a result bool is exempt via COMMAND_VERBS. A member
+ * may also opt out with an
  * @imperative docblock tag. Accessors, the constructor, computed names, magic
- * names and type-predicate guards (x is T) are exempt. The return type is resolved
- * from type information - inferred booleans and awaited Promise<boolean> included -
- * so the rule degrades to a no-op when no type information is available. The
- * accepted vocabulary can be widened per consumer through the rule options.
+ * names and type-predicate guards (x is T) are exempt. The return type is
+ * resolved from type information - inferred booleans and awaited
+ * Promise<boolean> included - so the rule degrades to a no-op when no type
+ * information is available. The accepted vocabulary can be widened per consumer
+ * through the rule options.
  *
  * @author      Ben Carey <bdmc@sinemacula.co.uk>
  * @copyright   2026 Sine Macula Limited
@@ -293,13 +301,14 @@ export default createRule({
         const services = ESLintUtils.getParserServices(context, true);
 
         // Without a type-checker program the return type can't be resolved, so
-        // the rule cannot decide anything; degrade to a no-op rather than throw.
+        // the rule cannot decide anything; degrade to a no-op rather than
+        // throw.
         if (!services.program) {
             return {};
         }
 
-        // Merge consumer additions onto the defaults so a downstream ruleset can
-        // widen the accepted vocabulary without losing the built-in words.
+        // Merge consumer additions onto the defaults so a downstream ruleset
+        // can widen the accepted vocabulary without losing the built-in words.
         const state = {
             context,
             services,

package/js/eslint/rules/lib.js

@@ -12,7 +12,9 @@ export const createRule = ESLintUtils.RuleCreator(
     name => `https://github.com/sinemacula/coding-standards#${name}`,
 );
 
-/** Whether the file is a TypeScript declaration file (.d.ts, .d.mts, .d.cts). */
+/**
+ * Whether the file is a TypeScript declaration file (.d.ts, .d.mts, .d.cts).
+ */
 export function isDeclarationFile(filename) {
     return /\.d\.[cm]?ts$/.test(filename);
 }
@@ -78,7 +80,9 @@ export function superClassName(klass) {
     return null;
 }
 
-/** Whether the class reads as a test class (by its own or its parent's name). */
+/**
+ * Whether the class reads as a test class (by its own or its parent's name).
+ */
 export function isTestClass(klass) {
     if (klass.id?.name?.endsWith('Test')) {
         return true;

package/js/eslint/rules/max-methods-per-class.js

@@ -2,8 +2,8 @@ import { createRule, isTestClass, isTestPath } from './lib.js';
 
 /** Whether a class member counts towards the method total. */
 function isCountedMethod(member) {
-    // An overload signature shares its name with the implementation below it, so it
-    // carries no body and is not counted a second time.
+    // An overload signature shares its name with the implementation below it,
+    // so it carries no body and is not counted a second time.
     return member.type === 'MethodDefinition'
         && member.value.type !== 'TSEmptyBodyFunctionExpression';
 }
@@ -28,8 +28,8 @@ function countMethods(node) {
  * Every method declared on the class body counts, including the constructor,
  * static methods and get/set accessors; a method spread across overload
  * signatures counts once, through its implementation. Methods on a nested class
- * belong to that class, not the one enclosing it. Test code legitimately gathers
- * many methods on one fixture, so a test file or test class is exempt.
+ * belong to that class, not the one enclosing it. Test code legitimately
+ * gathers many methods on one fixture, so a test file or test class is exempt.
  *
  * @author      Ben Carey <bdmc@sinemacula.co.uk>
  * @copyright   2026 Sine Macula Limited

package/js/eslint/rules/no-base-error.js

@@ -3,7 +3,10 @@ import { createRule, isTestPath } from './lib.js';
 /** Global objects whose `Error` member resolves to the base `Error`. */
 const GLOBAL_OBJECTS = new Set(['globalThis', 'window', 'global', 'self']);
 
-/** Strips the `as`, `satisfies` and non-null wrappers a throw argument may carry. */
+/**
+ * Strips the `as`, `satisfies` and non-null wrappers a throw argument may
+ * carry.
+ */
 function unwrapType(node) {
     let current = node;
 
@@ -36,7 +39,10 @@ function isGlobalError(callee) {
         && isErrorProperty(callee.property);
 }
 
-/** Whether a construction callee denotes the base `Error`, directly or through a global object. */
+/**
+ * Whether a construction callee denotes the base `Error`, directly or through a
+ * global object.
+ */
 function isBaseError(callee) {
     if (callee.type === 'Identifier') {
         return callee.name === 'Error';
@@ -55,11 +61,11 @@ function isBaseError(callee) {
  * The check is syntactic. It flags a throw whose argument constructs the base
  * `Error`, whether named directly (`new Error()`) or reached through a global
  * object (`new globalThis.Error()`, `new window.Error()`). A `throw ... as X`,
- * `throw ...!` or `satisfies` annotation is unwrapped before the construction is
- * inspected, so the annotation cannot hide the throw. Subclasses
- * (`new NotFoundError()`) and the specific built-ins (`new TypeError()`) read as
- * domain-specific and pass; a re-thrown variable (`throw err`), a qualified name
- * (`new foo.Error()`) and a base `Error` built for a non-throw use
+ * `throw ...!` or `satisfies` annotation is unwrapped before the construction
+ * is inspected, so the annotation cannot hide the throw. Subclasses
+ * (`new NotFoundError()`) and the specific built-ins (`new TypeError()`) read
+ * as domain-specific and pass; a re-thrown variable (`throw err`), a qualified
+ * name (`new foo.Error()`) and a base `Error` built for a non-throw use
  * (`const e = new Error()`) fall outside the pattern. Only the base `Error` is
  * ever a candidate, so listing `Error` in the `allow` option is the one way to
  * permit it; any other name has nothing to match and stays inert.

package/js/eslint/rules/no-interface-prefix.js

@@ -1,6 +1,9 @@
 import { createRule } from './lib.js';
 
-/** Disallowed "I" prefix: a capital I directly followed by another uppercase letter. */
+/**
+ * Disallowed "I" prefix: a capital I directly followed by another uppercase
+ * letter.
+ */
 const PREFIX_PATTERN = /^I[A-Z]/;
 
 /** A global or string-named module block augments types we do not own. */
@@ -31,7 +34,9 @@ export default createRule({
     create(context) {
         const { sourceCode } = context;
 
-        /** Report a declaration whose name carries the disallowed "I" prefix. */
+        /**
+         * Report a declaration whose name carries the disallowed "I" prefix.
+         */
         const check = (node, kind) => {
             const name = node.id.name;
 
@@ -39,7 +44,8 @@ export default createRule({
                 return;
             }
 
-            // Augmenting an external module or the global scope cannot rename it.
+            // Augmenting an external module or the global scope cannot rename
+            // it.
             if (sourceCode.getAncestors(node).some(isExternalAugmentation)) {
                 return;
             }

package/js/eslint/rules/no-mutable-static.js

@@ -1,12 +1,16 @@
 import { ASTUtils } from '@typescript-eslint/utils';
 import { createRule, isAmbient, isDeclarationFile, isTestClass, isTestPath, nearestClass } from './lib.js';
 
-/** Unwrap a rest element to its bound target, else return the node unchanged. */
+/**
+ * Unwrap a rest element to its bound target, else return the node unchanged.
+ */
 function restTarget(node) {
     return node.type === 'RestElement' ? node.argument : node;
 }
 
-/** The destructuring children of a pattern that may bind further identifiers. */
+/**
+ * The destructuring children of a pattern that may bind further identifiers.
+ */
 function patternChildren(pattern) {
     switch (pattern.type) {
         case 'ArrayPattern':
@@ -22,7 +26,10 @@ function patternChildren(pattern) {
     }
 }
 
-/** Collect the bound identifiers of a declarator target, unwrapping destructuring. */
+/**
+ * Collect the bound identifiers of a declarator target, unwrapping
+ * destructuring.
+ */
 function boundIdentifiers(pattern, out) {
     if (pattern.type === 'Identifier') {
         out.push(pattern);
@@ -36,7 +43,8 @@ function boundIdentifiers(pattern, out) {
 
 /**
  * Whether a resolved binding is a mutable local `let`/`var` (not const, class,
- * function, import or an ambient declaration), and so publishes live module state.
+ * function, import or an ambient declaration), and so publishes live module
+ * state.
  */
 function bindsMutableVariable(variable, filename) {
     if (isDeclarationFile(filename)) {
@@ -48,7 +56,9 @@ function bindsMutableVariable(variable, filename) {
     );
 }
 
-/** Matches @managed-static only at a docblock tag position, never inside prose. */
+/**
+ * Matches @managed-static only at a docblock tag position, never inside prose.
+ */
 const MANAGED_TAG = /(?:^|[\s*])@managed-static(?![-\w])/i;
 
 /**
@@ -62,8 +72,8 @@ function hasManagedTag(node, sourceCode) {
         return true;
     }
 
-    // A docblock tucked between the decorators and the declaration sits before the
-    // first token after the last decorator, not before the whole member.
+    // A docblock tucked between the decorators and the declaration sits before
+    // the first token after the last decorator, not before the whole member.
     if (node.decorators?.length) {
         const afterDecorators = sourceCode.getTokenAfter(node.decorators.at(-1));
         const inner = afterDecorators && sourceCode.getCommentsBefore(afterDecorators).at(-1);
@@ -74,7 +84,9 @@ function hasManagedTag(node, sourceCode) {
     return false;
 }
 
-/** A readable name for a class member key, including private and computed forms. */
+/**
+ * A readable name for a class member key, including private and computed forms.
+ */
 function describeKey(node, sourceCode) {
     if (node.computed) {
         return `[${sourceCode.getText(node.key)}]`;
@@ -91,7 +103,10 @@ function describeKey(node, sourceCode) {
     return node.key.name;
 }
 
-/** Report each identifier bound by an inline `export let`/`export var` declaration. */
+/**
+ * Report each identifier bound by an inline `export let`/`export var`
+ * declaration.
+ */
 function reportInlineExports(node, context) {
     const declaration = node.declaration;
 
@@ -116,7 +131,8 @@ function reportInlineExports(node, context) {
 
 /** Report `export { x }` specifiers that publish a mutable local binding. */
 function reportSpecifierExports(node, context) {
-    // A re-export carries no local binding; a type-only export carries no runtime one.
+    // A re-export carries no local binding; a type-only export carries no
+    // runtime one.
     if (node.source || node.exportKind === 'type') {
         return;
     }
@@ -137,18 +153,18 @@ function reportSpecifierExports(node, context) {
 }
 
 /**
- * Forbids mutable module-level and class-level static state: exported `let`/`var`
- * bindings (declared inline or published through an `export { ... }` specifier)
- * and non-readonly `static` class fields, including `static accessor`
- * auto-accessors. All are global mutable state; `const` and `readonly` express the
- * read-only configuration this allows.
+ * Forbids mutable module-level and class-level static state: exported
+ * `let`/`var` bindings (declared inline or published through an
+ * `export { ... }` specifier) and non-readonly `static` class fields, including
+ * `static accessor` auto-accessors. All are global mutable state; `const` and
+ * `readonly` express the read-only configuration this allows.
  *
- * The check is syntactic, not write-sensitive: a static is flagged whether or not
- * a reassignment is visible, since cross-file writes are out of a per-file rule's
- * reach. Deliberately mutated statics opt out with a `@managed-static` doc tag on
- * the field or its declaring class, and test classes are exempt. Module scope is
- * limited to exported bindings; an unexported module `let` stays local and is left
- * alone.
+ * The check is syntactic, not write-sensitive: a static is flagged whether or
+ * not a reassignment is visible, since cross-file writes are out of a per-file
+ * rule's reach. Deliberately mutated statics opt out with a `@managed-static`
+ * doc tag on the field or its declaring class, and test classes are exempt.
+ * Module scope is limited to exported bindings; an unexported module `let`
+ * stays local and is left alone.
  *
  * @author      Ben Carey <bdmc@sinemacula.co.uk>
  * @copyright   2026 Sine Macula Limited
@@ -170,7 +186,10 @@ export default createRule({
     create(context) {
         const { sourceCode } = context;
 
-        /** Whether a static member is exempt: test code or an opted-out declaration. */
+        /**
+         * Whether a static member is exempt: test code or an opted-out
+         * declaration.
+         */
         const isStaticExempt = node => {
             if (isTestPath(context.filename)) {
                 return true;
@@ -185,7 +204,10 @@ export default createRule({
             return hasManagedTag(node, sourceCode) || (klass !== null && hasManagedTag(klass, sourceCode));
         };
 
-        /** Flag a non-readonly static field or auto-accessor as mutable static state. */
+        /**
+         * Flag a non-readonly static field or auto-accessor as mutable static
+         * state.
+         */
         const inspectStatic = node => {
             if (!node.static || node.readonly || isAmbient(node, context.filename) || isStaticExempt(node)) {
                 return;

package/js/eslint/rules/require-readonly-public-property.js

@@ -82,7 +82,8 @@ export default createRule({
                 });
             },
             'AccessorProperty, TSAbstractAccessorProperty'(node) {
-                // An auto-accessor cannot be readonly, so a public one is always mutable.
+                // An auto-accessor cannot be readonly, so a public one is
+                // always mutable.
                 if (isOutOfScope(node) || isExempt(node)) {
                     return;
                 }
@@ -115,7 +116,10 @@ function isNonPublic(node) {
         || node.accessibility === 'protected';
 }
 
-/** Whether a class property is outside the public-mutable scope: static, ambient, or non-public. */
+/**
+ * Whether a class property is outside the public-mutable scope: static,
+ * ambient, or non-public.
+ */
 function isOutOfScope(node) {
     return node.static || node.declare || isNonPublic(node);
 }

package/js/eslint/rules/valid-enum-member-name.js

@@ -32,9 +32,9 @@ export default createRule({
         return {
             TSEnumMember(node) {
                 const id = node.id;
-                // A member name is either a bare identifier or a string literal;
-                // a string literal is checked by its resolved value, not the raw
-                // source text.
+                // A member name is either a bare identifier or a string
+                // literal; a string literal is checked by its resolved value,
+                // not the raw source text.
                 const name = id.type === 'Identifier' ? id.name : String(id.value);
 
                 if (!NAME_PATTERN.test(name)) {

package/js/eslint/vue.js

@@ -0,0 +1,46 @@
+import checkFile from 'eslint-plugin-check-file';
+import pluginVue from 'eslint-plugin-vue';
+import tseslint from 'typescript-eslint';
+
+/**
+ * Opt-in Vue layer: the single-file-component rules. Registers the SFC parser
+ * so `.vue` files are linted at all, resolves `<script lang="ts">` blocks
+ * through the TypeScript parser, and holds component filenames to the same
+ * kebab-case convention the shared formatter enforces on plain sources.
+ *
+ * This layer also carries the template layout rules, which the shared
+ * formatter cannot: it does not understand single-file components, so `.vue`
+ * markup would otherwise go unformatted entirely.
+ *
+ * Additive, and deliberately unlike the type-aware layer: it carries no base
+ * rules of its own, so spread it after whichever layer a repo already uses
+ * rather than in place of one. Vue is orthogonal to type-awareness, and a
+ * repo enabling both would otherwise apply the base rules twice.
+ *
+ * @author      Ben Carey <bdmc@sinemacula.co.uk>
+ * @copyright   2026 Sine Macula Limited
+ */
+export default [
+    ...pluginVue.configs['flat/recommended-error'],
+    {
+        files: ['**/*.vue'],
+        plugins: {
+            'check-file': checkFile,
+        },
+        languageOptions: {
+            parserOptions: {
+                parser: tseslint.parser,
+            },
+        },
+        rules: {
+            // The template rules indent by two; the shared formatter is four.
+            'vue/html-indent': ['error', 4],
+
+            'check-file/filename-naming-convention': ['error', {
+                '**/*.vue': 'KEBAB_CASE',
+            }, {
+                ignoreMiddleExtensions: true,
+            }],
+        },
+    },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sinemacula/coding-standards",
-    "version": "1.9.2",
+    "version": "1.11.0",
     "description": "Centralized coding standards, static analysis configurations, and code quality tooling for all Sine Macula repositories.",
     "license": "Apache-2.0",
     "author": "Ben Carey <bdmc@sinemacula.co.uk>",
@@ -35,6 +35,7 @@
     "exports": {
         "./js/eslint": "./js/eslint/index.js",
         "./js/eslint/type-checked": "./js/eslint/type-checked.js",
+        "./js/eslint/vue": "./js/eslint/vue.js",
         "./*": "./*"
     },
     "scripts": {
@@ -45,29 +46,44 @@
         "@typescript-eslint/rule-tester": "^8.0.0",
         "@typescript-eslint/utils": "^8.0.0",
         "eslint": "^9.0.0",
+        "eslint-plugin-check-file": "^3.0.0",
         "eslint-plugin-jsdoc": "^63.0.13",
+        "eslint-plugin-vue": "^10.0.0",
         "typescript": "^5.0.0",
         "typescript-eslint": "^8.0.0",
-        "vitest": "^3.0.0"
+        "vitest": "^3.0.0",
+        "vue-eslint-parser": "^10.0.0"
     },
     "peerDependencies": {
         "eslint": ">=9",
+        "eslint-plugin-check-file": ">=3",
         "eslint-plugin-jsdoc": ">=48",
+        "eslint-plugin-vue": ">=10",
         "typescript": ">=4.8.4",
-        "typescript-eslint": "^8"
+        "typescript-eslint": "^8",
+        "vue-eslint-parser": ">=10"
     },
     "peerDependenciesMeta": {
         "eslint": {
             "optional": true
         },
+        "eslint-plugin-check-file": {
+            "optional": true
+        },
         "eslint-plugin-jsdoc": {
             "optional": true
         },
+        "eslint-plugin-vue": {
+            "optional": true
+        },
         "typescript": {
             "optional": true
         },
         "typescript-eslint": {
             "optional": true
+        },
+        "vue-eslint-parser": {
+            "optional": true
         }
     },
     "publishConfig": {