@noxickon/codex 2.0.1 → 3.0.0

package/README.md

@@ -19,6 +19,7 @@ npm install --save-dev \
   eslint \
   prettier \
   @eslint/js \
+  @stylistic/eslint-plugin \
   typescript-eslint \
   globals \
   eslint-config-prettier \
@@ -56,6 +57,7 @@ npm install --save-dev \
   eslint \
   prettier \
   @eslint/js \
+  @stylistic/eslint-plugin \
   typescript-eslint \
   globals \
   eslint-config-prettier \
@@ -120,25 +122,11 @@ export default createReactConfig({
 });
 ```
 
-##### Blank-line spacing (CSS / HTML):
+##### Blank-line spacing:
 
-The `@noxickon/blank-line-spacing` rule enforces direction-aware blank lines between statements. It is already included in the base, React, and Node configs for `.ts` / `.tsx` / `.js` / `.jsx` files — no setup needed.
+Blank lines are enforced via [ESLint Stylistic](https://eslint.style) — `@stylistic/padding-line-between-statements` and `@stylistic/lines-between-class-members`. They are included in the base, React, and Node configs for `.ts` / `.tsx` / `.js` / `.jsx` files — no setup needed. Collapsing of multiple blank lines and trimming of block edges is left to Prettier.
 
-For CSS and HTML, add the matching configs. Each requires its optional peer dependency (`@eslint/css` and `@html-eslint/parser` respectively):
-
-###### eslint.config.js
-
-```
-import { createReactConfig } from '@noxickon/codex/eslint/react';
-import { createCssConfig } from '@noxickon/codex/eslint/css';
-import { createHtmlConfig } from '@noxickon/codex/eslint/html';
-
-export default [
-    ...createReactConfig(),
-    ...createCssConfig(),
-    ...createHtmlConfig(),
-];
-```
+CSS and HTML blank-line spacing is owned entirely by Prettier (no ESLint config required).
 
 ### Prettier
 
@@ -194,7 +182,7 @@ export default createPrettierConfig({
 - Perfectionist (Auto-sorting)
 - Unused Imports
 - Sort Destructure Keys
-- Codex (`@noxickon/blank-line-spacing` — direction-aware blank-line spacing; CSS/HTML variants opt-in)
+- ESLint Stylistic (Blank-line spacing — `padding-line-between-statements`, `lines-between-class-members`)
 - ESLint Config Prettier (Disables ESLint rules that conflict with Prettier)
 
 **React (additional):**

package/eslint/base.config.js

@@ -19,7 +19,7 @@ import unusedImports from 'eslint-plugin-unused-imports';
 import globals from 'globals';
 import tseslint from 'typescript-eslint';
 
-import { codexPlugin } from './plugin.js';
+import { blankLineRules, stylisticPlugin } from './blank-lines.js';
 
 export function createBaseConfig(options = {}) {
   const { tailwindEntryPoint = './src/tailwind.css', enableTailwind = true } = options;
@@ -56,15 +56,15 @@ export function createBaseConfig(options = {}) {
         globals: globals.browser,
       },
       plugins: {
-        '@noxickon': codexPlugin,
+        '@stylistic': stylisticPlugin,
         perfectionist,
         'sort-destructure-keys': sortDestructureKeys,
         unicorn,
         'unused-imports': unusedImports,
       },
       rules: {
-        // Blank-line spacing - direction-aware blank lines between statements
-        '@noxickon/blank-line-spacing': 'warn',
+        // Blank-line spacing - type-based padding (Stylistic); Prettier owns collapsing
+        ...blankLineRules,
 
         // Unicorn - modern JS/TS best practices
         ...unicorn.configs.recommended.rules,
@@ -145,6 +145,10 @@ export function createBaseConfig(options = {}) {
         'unicorn/import-style': 'off',
         'unicorn/no-useless-undefined': 'off',
 
+        // globalThis.setTimeout is intentional: it pins the DOM return type
+        // (number) instead of leaking NodeJS.Timeout into shipped library types.
+        'unicorn/no-unnecessary-global-this': 'off',
+
         // Perfectionist - auto-sorting
         'perfectionist/sort-interfaces': ['error'],
         'perfectionist/sort-object-types': ['error'],
@@ -209,6 +213,43 @@ export function createBaseConfig(options = {}) {
         ],
       },
     },
+    {
+      // Stories embed literal JSX in docs `source.code` strings and define
+      // local example render helpers, which fight several unicorn rules.
+      files: ['**/*.stories.{ts,tsx,js,jsx}'],
+      rules: {
+        // {onClick} in a code:`...` string is documentation, not interpolation.
+        'unicorn/no-incorrect-template-string-interpolation': 'off',
+        // Example render helpers are intentionally local to the story.
+        'unicorn/consistent-function-scoping': 'off',
+        // Stories mock backends by assigning globalThis.fetch and friends.
+        'unicorn/no-global-object-property-assignment': 'off',
+        // Fixtures read members off `new` directly (new AbortController().signal).
+        'unicorn/no-unreadable-new-expression': 'off',
+      },
+    },
+    {
+      // Test files and test infra fight several unicorn rules with standard
+      // testing patterns (DOM queries, global mocks, prototype patches).
+      files: [
+        '**/*.{test,spec}.{ts,tsx,js,jsx}',
+        '**/{test,tests,__tests__}/**/*.{ts,tsx,js,jsx}',
+      ],
+      rules: {
+        // Simple element queries; :scope is behaviorally identical here.
+        'unicorn/prefer-scoped-selector': 'off',
+        // Local helpers inside describe blocks are intentional for locality.
+        'unicorn/consistent-function-scoping': 'off',
+        // Mocking browser globals (globalThis.ResizeObserver = ...) is standard.
+        'unicorn/no-global-object-property-assignment': 'off',
+        // Prototype mocks (HTMLElement.prototype.x = function () { this... }).
+        'unicorn/no-this-outside-of-class': 'off',
+        // Fixtures read members off `new` directly (new AbortController().signal).
+        'unicorn/no-unreadable-new-expression': 'off',
+        // Tracking call order with () => arr.push(x) ignores the return value.
+        'unicorn/no-return-array-push': 'off',
+      },
+    },
   ];
 
   // Add Tailwind config if enabled

package/eslint/blank-lines.js

@@ -0,0 +1,24 @@
+/**
+ * Shared blank-line spacing via ESLint Stylistic.
+ * Type-based padding rules (the community standard); Prettier owns blank
+ * collapsing and block-edge trimming, so those are intentionally not set here.
+ */
+
+import stylistic from '@stylistic/eslint-plugin';
+
+export const stylisticPlugin = stylistic;
+
+export const blankLineRules = {
+  '@stylistic/padding-line-between-statements': [
+    'warn',
+    { blankLine: 'always', prev: '*', next: 'return' },
+    { blankLine: 'always', prev: 'directive', next: '*' },
+    { blankLine: 'any', prev: 'directive', next: 'directive' },
+    { blankLine: 'always', prev: ['case', 'default'], next: '*' },
+    { blankLine: 'always', prev: 'block-like', next: '*' },
+    { blankLine: 'always', prev: '*', next: 'block-like' },
+    { blankLine: 'always', prev: ['function', 'class'], next: '*' },
+    { blankLine: 'always', prev: '*', next: ['function', 'class'] },
+  ],
+  '@stylistic/lines-between-class-members': ['warn', 'always', { exceptAfterSingleLine: true }],
+};

package/eslint/blank-lines.test.js

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { blankLineRules, stylisticPlugin } from './blank-lines.js';
+
+describe('blank-lines', () => {
+  it('wires only Stylistic rules', () => {
+    const keys = Object.keys(blankLineRules);
+
+    assert.ok(keys.length > 0);
+    assert.ok(keys.every((key) => key.startsWith('@stylistic/')));
+  });
+
+  it('references rules that the Stylistic plugin actually provides', () => {
+    for (const key of Object.keys(blankLineRules)) {
+      const ruleName = key.slice('@stylistic/'.length);
+
+      assert.ok(stylisticPlugin.rules[ruleName], `missing rule: ${ruleName}`);
+    }
+  });
+
+  it('configures padding-line-between-statements as a warning', () => {
+    const [severity] = blankLineRules['@stylistic/padding-line-between-statements'];
+
+    assert.equal(severity, 'warn');
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noxickon/codex",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "author": "noxickon",
   "license": "MIT",
   "description": "Shared ESLint & Prettier configuration for noxickon projects",
@@ -12,19 +12,14 @@
     "test": "node --test \"eslint/**/*.test.js\""
   },
   "devDependencies": {
-    "@eslint/css": ">=0.12.0",
-    "@html-eslint/parser": ">=0.62.0",
-    "eslint-plugin-react-hooks": ">=6.0.0",
-    "vue-eslint-parser": ">=10.0.0"
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "eslint-plugin-react-hooks": ">=6.0.0"
   },
   "exports": {
     "./prettier": "./prettier.config.js",
     "./eslint/base": "./eslint/base.config.js",
     "./eslint/node": "./eslint/node.config.js",
-    "./eslint/react": "./eslint/react.config.js",
-    "./eslint/vue": "./eslint/vue.config.js",
-    "./eslint/html": "./eslint/html.config.js",
-    "./eslint/css": "./eslint/css.config.js"
+    "./eslint/react": "./eslint/react.config.js"
   },
   "files": [
     "eslint",
@@ -37,9 +32,8 @@
   ],
   "peerDependencies": {
     "@eslint-react/eslint-plugin": ">=4.0.0",
-    "@eslint/css": ">=0.12.0",
     "@eslint/js": ">=10.0.0",
-    "@html-eslint/parser": ">=0.62.0",
+    "@stylistic/eslint-plugin": ">=5.0.0",
     "eslint": ">=10.4.0",
     "eslint-config-prettier": ">=10.0.0",
     "eslint-plugin-better-tailwindcss": ">=4.0.0",
@@ -55,22 +49,12 @@
     "globals": ">=17.1.0",
     "prettier": ">=3.8.1",
     "prettier-plugin-tailwindcss": ">=0.7.0",
-    "typescript-eslint": ">=8.57.0",
-    "vue-eslint-parser": ">=10.0.0"
+    "typescript-eslint": ">=8.57.0"
   },
   "peerDependenciesMeta": {
     "eslint-plugin-better-tailwindcss": {
       "optional": true
     },
-    "vue-eslint-parser": {
-      "optional": true
-    },
-    "@html-eslint/parser": {
-      "optional": true
-    },
-    "@eslint/css": {
-      "optional": true
-    },
     "eslint-plugin-n": {
       "optional": true
     },

package/eslint/css.config.js

@@ -1,28 +0,0 @@
-/**
- * CSS ESLint configuration (stripped-down blank-line spacing).
- * Requires the optional peer dependency `@eslint/css`.
- * @returns {Array} ESLint flat config array
- */
-
-import css from '@eslint/css';
-
-import { codexPlugin } from './plugin.js';
-
-export function createCssConfig() {
-  return [
-    {
-      files: ['**/*.css'],
-      language: 'css/css',
-      languageOptions: {
-        tolerant: true,
-      },
-      plugins: {
-        css,
-        '@noxickon': codexPlugin,
-      },
-      rules: {
-        '@noxickon/blank-line-spacing-css': 'warn',
-      },
-    },
-  ];
-}

package/eslint/html.config.js

@@ -1,26 +0,0 @@
-/**
- * HTML ESLint configuration (blank-line spacing for elements).
- * Requires the optional peer dependency `@html-eslint/parser`.
- * @returns {Array} ESLint flat config array
- */
-
-import htmlParser from '@html-eslint/parser';
-
-import { codexPlugin } from './plugin.js';
-
-export function createHtmlConfig() {
-  return [
-    {
-      files: ['**/*.html'],
-      languageOptions: {
-        parser: htmlParser,
-      },
-      plugins: {
-        '@noxickon': codexPlugin,
-      },
-      rules: {
-        '@noxickon/blank-line-spacing-html': 'warn',
-      },
-    },
-  ];
-}

package/eslint/plugin.js

@@ -1,15 +0,0 @@
-import blankLineSpacing from './rules/blank-line-spacing.js';
-import blankLineSpacingCss from './rules/blank-line-spacing-css.js';
-import blankLineSpacingHtml from './rules/blank-line-spacing-html.js';
-
-export const codexPlugin = {
-  meta: {
-    name: '@noxickon/codex',
-    version: '1.3.1',
-  },
-  rules: {
-    'blank-line-spacing': blankLineSpacing,
-    'blank-line-spacing-html': blankLineSpacingHtml,
-    'blank-line-spacing-css': blankLineSpacingCss,
-  },
-};

package/eslint/rules/blank-line-spacing-css.js

@@ -1,51 +0,0 @@
-/**
- * Stripped-down blank-line rule for CSS (H1): after a multiline block
- * (`{ ... }` spanning multiple lines), require one blank line before the
- * next rule/at-rule. Declarations inside a block are not touched (H2).
- * Requires the optional peer dependency `@eslint/css`.
- */
-
-export default {
-  meta: {
-    type: 'layout',
-    docs: {
-      description: 'Require a blank line after a multiline CSS block',
-    },
-    fixable: 'whitespace',
-    schema: [],
-    messages: {
-      expected: 'Expected a blank line after the previous block.',
-    },
-  },
-  create(context) {
-    function process(children) {
-      for (let i = 1; i < children.length; i += 1) {
-        const prev = children[i - 1];
-        const curr = children[i];
-
-        if (prev.loc.start.line === prev.loc.end.line) {
-          continue;
-        }
-
-        if (curr.loc.start.line - prev.loc.end.line - 1 < 1) {
-          const end = prev.loc.end.offset;
-
-          context.report({
-            loc: curr.loc.start,
-            messageId: 'expected',
-            fix: (fixer) => fixer.insertTextAfterRange([end, end], '\n'),
-          });
-        }
-      }
-    }
-
-    return {
-      StyleSheet: (node) => process(node.children),
-      Atrule: (node) => {
-        if (node.block && node.block.children) {
-          process(node.block.children);
-        }
-      },
-    };
-  },
-};

package/eslint/rules/blank-line-spacing-html.js

@@ -1,38 +0,0 @@
-/**
- * Enforces direction-aware blank lines between HTML elements (Tag nodes).
- * Mirrors the element matrix used for JSX/Vue templates:
- *   single el -> single el : no blank
- *   single el -> multiline el (lone) : no blank
- *   multiline el -> el : blank
- *   group(2+ singles) -> multiline el : blank
- * Requires the optional peer dependency `@html-eslint/parser`.
- */
-
-import { processElementChildren } from './shared.js';
-
-const HTML_ELEMENT_TYPES = new Set(['Tag']);
-
-export default {
-  meta: {
-    type: 'layout',
-    docs: {
-      description: 'Enforce direction-aware blank lines between HTML elements',
-    },
-    fixable: 'whitespace',
-    schema: [],
-    messages: {
-      expected: 'Expected a blank line before this element.',
-      unexpected: 'Unexpected blank line before this element.',
-    },
-  },
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const process = (children) =>
-      processElementChildren(context, sourceCode, children, HTML_ELEMENT_TYPES, 'Text', (node) => node.range);
-
-    return {
-      Document: (node) => process(node.children),
-      Tag: (node) => process(node.children),
-    };
-  },
-};

package/eslint/rules/blank-line-spacing.js

@@ -1,254 +0,0 @@
-/**
- * Enforces direction-aware blank lines between statements.
- *
- * Matrix (single = one source line, multiline = spans multiple lines):
- *   single   -> single    : no blank        (M1)
- *   single   -> multiline : no blank        (M2, "lone setup line")
- *   multiline-> single    : blank required   (M3)
- *   multiline-> multiline : blank required   (M4)
- *   group(2+ singles) -> multiline : blank required (M5)
- *
- * Extra rules:
- *   - Block G: in a block of >= 3 statements, a blank is required before a
- *     trailing single-line exit (return/throw/break/continue).
- *   - N1: function/class/top-level declarations always get a blank before them
- *     (M2 "no blank" applies only to control-flow/expression blocks).
- *   - N2a: blanks that violate "no blank" are removed (normalisation).
- *   - N2b: a single blank directly above a leading comment is preserved.
- *   - D4: import statements and re-export lists are left untouched.
- */
-
-import { processElementChildren } from './shared.js';
-
-const EXIT_TYPES = new Set(['ReturnStatement', 'ThrowStatement', 'BreakStatement', 'ContinueStatement']);
-const FUNCTION_INIT_TYPES = new Set(['ArrowFunctionExpression', 'FunctionExpression', 'ClassExpression']);
-const JSX_ELEMENT_TYPES = new Set(['JSXElement', 'JSXFragment']);
-const VUE_ELEMENT_TYPES = new Set(['VElement']);
-
-function isMultiline(node) {
-  return node.loc.start.line !== node.loc.end.line;
-}
-
-function isExit(node) {
-  return EXIT_TYPES.has(node.type);
-}
-
-function isSkipped(node) {
-  if (node.type === 'ImportDeclaration' || node.type === 'ExportAllDeclaration') {
-    return true;
-  }
-
-  return node.type === 'ExportNamedDeclaration' && !node.declaration;
-}
-
-function isDefinitionLike(node) {
-  switch (node.type) {
-    case 'FunctionDeclaration':
-    case 'ClassDeclaration':
-    case 'TSInterfaceDeclaration':
-    case 'TSTypeAliasDeclaration':
-    case 'TSEnumDeclaration':
-    case 'TSModuleDeclaration':
-    case 'ExportDefaultDeclaration':
-      return true;
-    case 'ExportNamedDeclaration':
-      return Boolean(node.declaration);
-    case 'VariableDeclaration':
-      return node.declarations.some((d) => d.init && FUNCTION_INIT_TYPES.has(d.init.type));
-    default:
-      return false;
-  }
-}
-
-function caseIsMultiline(switchCase) {
-  const body = switchCase.consequent;
-
-  if (body.length === 0) {
-    return false;
-  }
-
-  if (body.length === 1) {
-    return isMultiline(body[0]);
-  }
-
-  return true;
-}
-
-function getActualLastToken(sourceCode, node) {
-  const last = sourceCode.getLastToken(node);
-
-  if (!last || last.type !== 'Punctuator' || last.value !== ';') {
-    return last;
-  }
-
-  const prevToken = sourceCode.getTokenBefore(last);
-  const nextToken = sourceCode.getTokenAfter(last);
-  const semicolonLess = Boolean(
-    prevToken &&
-      nextToken &&
-      prevToken.range[0] >= node.range[0] &&
-      last.loc.start.line !== prevToken.loc.end.line &&
-      last.loc.end.line === nextToken.loc.start.line,
-  );
-
-  return semicolonLess ? prevToken : last;
-}
-
-export default {
-  meta: {
-    type: 'layout',
-    docs: {
-      description: 'Enforce direction-aware blank lines between statements',
-    },
-    fixable: 'whitespace',
-    schema: [],
-    messages: {
-      expected: 'Expected a blank line before this statement.',
-      unexpected: 'Unexpected blank line before this statement.',
-    },
-  },
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    function leadingComments(prevAnchor, node) {
-      return sourceCode
-        .getCommentsBefore(node)
-        .filter((comment) => comment.loc.start.line !== prevAnchor.loc.end.line);
-    }
-
-    function trailingAnchor(prevNode) {
-      const lastToken = getActualLastToken(sourceCode, prevNode);
-      const trailing = sourceCode
-        .getCommentsAfter(lastToken)
-        .filter((comment) => comment.loc.start.line === lastToken.loc.end.line);
-
-      return trailing.length > 0 ? trailing.at(-1) : lastToken;
-    }
-
-    function blankCountBetween(prevNode, node) {
-      const anchor = trailingAnchor(prevNode);
-      const comments = leadingComments(anchor, node);
-      const start = comments.length > 0 ? comments[0] : sourceCode.getFirstToken(node);
-
-      return start.loc.start.line - anchor.loc.end.line - 1;
-    }
-
-    function isGroupedSingle(prevPrev, prev, multilineOf) {
-      if (!prevPrev || isSkipped(prevPrev) || multilineOf(prevPrev)) {
-        return false;
-      }
-
-      return blankCountBetween(prevPrev, prev) === 0;
-    }
-
-    function needsBlank({ prevPrev, prev, curr, isLast, listLength, kind }) {
-      const multilineOf = kind === 'switch' ? caseIsMultiline : isMultiline;
-      const prevMulti = multilineOf(prev);
-      const currMulti = multilineOf(curr);
-
-      if (currMulti) {
-        if (kind === 'statement' && isDefinitionLike(curr)) {
-          return true;
-        }
-
-        if (prevMulti) {
-          return true;
-        }
-
-        return isGroupedSingle(prevPrev, prev, multilineOf);
-      }
-
-      if (prevMulti) {
-        return true;
-      }
-
-      return kind === 'statement' && isLast && listLength >= 3 && isExit(curr);
-    }
-
-    function checkPair(prev, curr, needBlank) {
-      const anchor = trailingAnchor(prev);
-      const comments = leadingComments(anchor, curr);
-      const start = comments.length > 0 ? comments[0] : sourceCode.getFirstToken(curr);
-      const blankCount = start.loc.start.line - anchor.loc.end.line - 1;
-
-      if (needBlank && blankCount < 1) {
-        context.report({
-          node: curr,
-          loc: start.loc,
-          messageId: 'expected',
-          fix: (fixer) => fixer.insertTextAfter(anchor, '\n'),
-        });
-
-        return;
-      }
-
-      if (!needBlank && blankCount > 0) {
-        if (comments.length > 0) {
-          return;
-        }
-
-        const between = sourceCode.text.slice(anchor.range[1], start.range[0]);
-        const indent = between.slice(between.lastIndexOf('\n') + 1);
-
-        context.report({
-          node: curr,
-          loc: start.loc,
-          messageId: 'unexpected',
-          fix: (fixer) => fixer.replaceTextRange([anchor.range[1], start.range[0]], `\n${indent}`),
-        });
-      }
-    }
-
-    function processList(list, kind = 'statement') {
-      for (let i = 1; i < list.length; i += 1) {
-        const prev = list[i - 1];
-        const curr = list[i];
-
-        if (isSkipped(prev) || isSkipped(curr)) {
-          continue;
-        }
-
-        const needBlank = needsBlank({
-          prevPrev: list[i - 2],
-          prev,
-          curr,
-          isLast: i === list.length - 1,
-          listLength: list.length,
-          kind,
-        });
-
-        checkPair(prev, curr, needBlank);
-      }
-    }
-
-    const rangeOf = (node) => node.range;
-    const processJsx = (children) =>
-      processElementChildren(context, sourceCode, children, JSX_ELEMENT_TYPES, 'JSXText', rangeOf);
-
-    const scriptVisitors = {
-      Program: (node) => processList(node.body),
-      BlockStatement: (node) => processList(node.body),
-      StaticBlock: (node) => processList(node.body),
-      SwitchCase: (node) => processList(node.consequent),
-      SwitchStatement: (node) => processList(node.cases, 'switch'),
-      ClassBody: (node) => processList(node.body),
-      TSModuleBlock: (node) => processList(node.body),
-      JSXElement: (node) => processJsx(node.children),
-      JSXFragment: (node) => processJsx(node.children),
-    };
-
-    const services = sourceCode.parserServices;
-
-    if (services && typeof services.defineTemplateBodyVisitor === 'function') {
-      return services.defineTemplateBodyVisitor(
-        {
-          VElement: (node) =>
-            processElementChildren(context, sourceCode, node.children, VUE_ELEMENT_TYPES, 'VText', rangeOf),
-        },
-        scriptVisitors,
-      );
-    }
-
-    return scriptVisitors;
-  },
-};

package/eslint/rules/blank-line-spacing.test.js

@@ -1,272 +0,0 @@
-import { RuleTester } from 'eslint';
-import { describe, it } from 'node:test';
-import tseslint from 'typescript-eslint';
-
-import rule from './blank-line-spacing.js';
-
-RuleTester.describe = describe;
-RuleTester.it = it;
-
-const js = new RuleTester({
-  languageOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-    parserOptions: { ecmaFeatures: { jsx: true } },
-  },
-});
-
-const ts = new RuleTester({
-  languageOptions: {
-    parser: tseslint.parser,
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-  },
-});
-
-js.run('blank-line-spacing', rule, {
-  valid: [
-    // M1: single -> single grouped
-    'const a = 1;\nconst b = 2;\nconst c = 3;',
-
-    // M2: lone setup -> multiline
-    'const userId = getId();\nif (userId === null) {\n  fail();\n}',
-
-    // M3: multiline -> single
-    'if (x) {\n  go();\n}\n\nconst y = 1;',
-
-    // M4: multiline -> multiline
-    'if (x) {\n  go();\n}\n\nfor (const i of list) {\n  use(i);\n}',
-
-    // M5: group of singles -> multiline
-    'const a = 1;\nconst b = 2;\n\nif (a + b > 0) {\n  go();\n}',
-
-    // Block G: <= 2 statements stay tight
-    'function f() {\n  doIt();\n  return true;\n}',
-
-    // Block G: >= 3 statements -> blank before exit
-    'function f() {\n  a();\n  b();\n\n  return true;\n}',
-
-    // Block G with throw
-    'function f() {\n  const x = a();\n  const y = b();\n\n  throw new Error(x + y);\n}',
-
-    // N1: function declaration always gets a blank before it
-    'const max = 10;\n\nfunction make() {\n  return max;\n}',
-
-    // N2b: blank above a comment is preserved (section divider)
-    'const config = load();\n\n// SECTION\nconst valid = config.ok;',
-
-    // comment does not break a group (no blank) -> group still needs blank before block
-    'const a = 1;\n// explains b\nconst b = 2;\n\nif (a + b) {\n  go();\n}',
-
-    // imports untouched (perfectionist owns them)
-    "import a from 'a';\n\nimport b from 'b';\nconst x = 1;",
-
-    // class: fields grouped, blank before method
-    'class C {\n  a = 1;\n  b = 2;\n\n  run() {\n    go();\n  }\n}',
-
-    // switch: single-line cases grouped, multiline case separated
-    'function pick(t) {\n  switch (t) {\n    case 1:\n      return a();\n    case 2:\n      return b();\n\n    case 3: {\n      const x = c();\n      return x;\n    }\n\n    default:\n      return d();\n  }\n}',
-
-    // multiline before exit already separated by M3, no extra blank
-    'function f() {\n  if (a) {\n    return 0;\n  }\n\n  return 1;\n}',
-
-    // JSX: single-line sibling elements grouped
-    'const x = (\n  <div>\n    <span>a</span>\n    <span>b</span>\n  </div>\n);',
-
-    // JSX: lone single element -> multiline element = no blank (T4/M2)
-    'const x = (\n  <div>\n    <span>a</span>\n    <ul>\n      <li>b</li>\n    </ul>\n  </div>\n);',
-
-    // JSX: multiline element -> following element = blank (T3)
-    'const x = (\n  <div>\n    <ul>\n      <li>a</li>\n    </ul>\n\n    <span>b</span>\n  </div>\n);',
-
-    // JSX: group of single elements -> multiline element = blank
-    'const x = (\n  <div>\n    <span>a</span>\n    <span>b</span>\n\n    <form>\n      <input />\n    </form>\n  </div>\n);',
-  ],
-  invalid: [
-    // M1 violation: stray blank between singles -> removed
-    {
-      code: 'const a = 1;\n\nconst b = 2;',
-      output: 'const a = 1;\nconst b = 2;',
-      errors: [{ messageId: 'unexpected' }],
-    },
-
-    // M2 violation: lone setup -> multiline should not have blank
-    {
-      code: 'const x = get();\n\nif (x) {\n  go();\n}',
-      output: 'const x = get();\nif (x) {\n  go();\n}',
-      errors: [{ messageId: 'unexpected' }],
-    },
-
-    // M3 violation: multiline -> single missing blank
-    {
-      code: 'if (x) {\n  go();\n}\nconst y = 1;',
-      output: 'if (x) {\n  go();\n}\n\nconst y = 1;',
-      errors: [{ messageId: 'expected' }],
-    },
-
-    // M5 violation: group of singles -> multiline missing blank
-    {
-      code: 'const a = 1;\nconst b = 2;\nif (a + b) {\n  go();\n}',
-      output: 'const a = 1;\nconst b = 2;\n\nif (a + b) {\n  go();\n}',
-      errors: [{ messageId: 'expected' }],
-    },
-
-    // Block G: 3 statements, missing blank before return
-    {
-      code: 'function f() {\n  a();\n  b();\n  return true;\n}',
-      output: 'function f() {\n  a();\n  b();\n\n  return true;\n}',
-      errors: [{ messageId: 'expected' }],
-    },
-
-    // N1: missing blank before function declaration
-    {
-      code: 'const max = 10;\nfunction make() {\n  return max;\n}',
-      output: 'const max = 10;\n\nfunction make() {\n  return max;\n}',
-      errors: [{ messageId: 'expected' }],
-    },
-
-    // insert blank before a leading comment (blank goes above the comment)
-    {
-      code: 'if (x) {\n  go();\n}\n// note\nconst y = 1;',
-      output: 'if (x) {\n  go();\n}\n\n// note\nconst y = 1;',
-      errors: [{ messageId: 'expected' }],
-    },
-
-    // trailing comment on prev does not get split when inserting
-    {
-      code: 'const a = 1; // keep\nif (a) {\n  go();\n}\nconst b = 2;',
-      output: 'const a = 1; // keep\nif (a) {\n  go();\n}\n\nconst b = 2;',
-      errors: [{ messageId: 'expected' }],
-    },
-
-    // JSX: stray blank between single elements removed
-    {
-      code: 'const x = (\n  <div>\n    <span>a</span>\n\n    <span>b</span>\n  </div>\n);',
-      output: 'const x = (\n  <div>\n    <span>a</span>\n    <span>b</span>\n  </div>\n);',
-      errors: [{ messageId: 'unexpected' }],
-    },
-
-    // JSX: multiline element -> single element missing blank
-    {
-      code: 'const x = (\n  <div>\n    <ul>\n      <li>a</li>\n    </ul>\n    <span>b</span>\n  </div>\n);',
-      output: 'const x = (\n  <div>\n    <ul>\n      <li>a</li>\n    </ul>\n\n    <span>b</span>\n  </div>\n);',
-      errors: [{ messageId: 'expected' }],
-    },
-  ],
-});
-
-let vueParser;
-
-try {
-  vueParser = (await import('vue-eslint-parser')).default;
-} catch {
-  vueParser = null;
-}
-
-if (vueParser) {
-  const vue = new RuleTester({
-    languageOptions: {
-      parser: vueParser,
-      parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
-    },
-  });
-
-  vue.run('blank-line-spacing (vue)', rule, {
-    valid: [
-      // script grouped + blank before function; template grouped + blank before multiline
-      '<script setup>\nconst a = 1;\nconst b = 2;\n\nfunction go() {\n  a();\n}\n</script>\n\n<template>\n  <span>a</span>\n  <span>b</span>\n\n  <ul>\n    <li>x</li>\n  </ul>\n</template>\n',
-    ],
-    invalid: [
-      // template: stray blank between single elements removed
-      {
-        code: '<template>\n  <span>a</span>\n\n  <span>b</span>\n</template>\n',
-        output: '<template>\n  <span>a</span>\n  <span>b</span>\n</template>\n',
-        errors: [{ messageId: 'unexpected' }],
-      },
-
-      // template: group of single elements -> multiline element = blank
-      {
-        code: '<template>\n  <span>a</span>\n  <span>b</span>\n  <ul>\n    <li>x</li>\n  </ul>\n</template>\n',
-        output: '<template>\n  <span>a</span>\n  <span>b</span>\n\n  <ul>\n    <li>x</li>\n  </ul>\n</template>\n',
-        errors: [{ messageId: 'expected' }],
-      },
-    ],
-  });
-}
-
-let htmlParser;
-
-try {
-  htmlParser = (await import('@html-eslint/parser')).default;
-} catch {
-  htmlParser = null;
-}
-
-if (htmlParser) {
-  const htmlRule = (await import('./blank-line-spacing-html.js')).default;
-  const html = new RuleTester({ languageOptions: { parser: htmlParser } });
-
-  html.run('blank-line-spacing-html', htmlRule, {
-    valid: [
-      '<div>\n  <span>a</span>\n  <span>b</span>\n</div>\n',
-      '<div>\n  <ul>\n    <li>a</li>\n  </ul>\n\n  <span>b</span>\n</div>\n',
-    ],
-    invalid: [
-      {
-        code: '<div>\n  <span>a</span>\n\n  <span>b</span>\n</div>\n',
-        output: '<div>\n  <span>a</span>\n  <span>b</span>\n</div>\n',
-        errors: [{ messageId: 'unexpected' }],
-      },
-      {
-        code: '<div>\n  <ul>\n    <li>a</li>\n  </ul>\n  <span>b</span>\n</div>\n',
-        output: '<div>\n  <ul>\n    <li>a</li>\n  </ul>\n\n  <span>b</span>\n</div>\n',
-        errors: [{ messageId: 'expected' }],
-      },
-    ],
-  });
-}
-
-let cssPlugin;
-
-try {
-  cssPlugin = (await import('@eslint/css')).default;
-} catch {
-  cssPlugin = null;
-}
-
-if (cssPlugin) {
-  const cssRule = (await import('./blank-line-spacing-css.js')).default;
-  const cssTester = new RuleTester({ plugins: { css: cssPlugin }, language: 'css/css' });
-
-  cssTester.run('blank-line-spacing-css', cssRule, {
-    valid: [
-      '.a {\n  color: red;\n}\n\n.b {\n  color: blue;\n}\n',
-      '.a { color: red; }\n.b { color: blue; }\n',
-    ],
-    invalid: [
-      {
-        code: '.a {\n  color: red;\n}\n.b {\n  color: blue;\n}\n',
-        output: '.a {\n  color: red;\n}\n\n.b {\n  color: blue;\n}\n',
-        errors: [{ messageId: 'expected' }],
-      },
-    ],
-  });
-}
-
-ts.run('blank-line-spacing (ts)', rule, {
-  valid: [
-    // export const arrow = definition-like -> blank before it (present)
-    'const max = 10;\n\nexport const make = (): number => {\n  return max;\n};',
-
-    // interface members are not touched; blank after the interface (M3) is required
-    'interface User {\n  id: string;\n  name: string;\n}\n\nconst x = 1;',
-  ],
-  invalid: [
-    // missing blank before exported arrow declaration
-    {
-      code: 'const max = 10;\nexport const make = (): number => {\n  return max;\n};',
-      output: 'const max = 10;\n\nexport const make = (): number => {\n  return max;\n};',
-      errors: [{ messageId: 'expected' }],
-    },
-  ],
-});

package/eslint/rules/shared.js

@@ -1,86 +0,0 @@
-/**
- * Shared element-spacing helpers used by the JSX/Vue, HTML rules.
- * Works on any node that exposes `loc` (line info) and a pair of absolute
- * text offsets via the `offsetsOf` accessor.
- */
-
-function isMultilineNode(node) {
-  return node.loc.start.line !== node.loc.end.line;
-}
-
-export function elementNeedsBlank(prevPrev, prev, curr) {
-  const prevMulti = isMultilineNode(prev);
-  const currMulti = isMultilineNode(curr);
-
-  if (currMulti) {
-    if (prevMulti) {
-      return true;
-    }
-
-    return Boolean(
-      prevPrev && !isMultilineNode(prevPrev) && prev.loc.start.line - prevPrev.loc.end.line - 1 === 0,
-    );
-  }
-
-  return prevMulti;
-}
-
-export function reportElementPair(context, sourceCode, prev, curr, needBlank, offsetsOf) {
-  const prevEnd = offsetsOf(prev)[1];
-  const currStart = offsetsOf(curr)[0];
-  const blankCount = curr.loc.start.line - prev.loc.end.line - 1;
-
-  if (needBlank && blankCount < 1) {
-    context.report({
-      node: curr,
-      loc: curr.loc.start,
-      messageId: 'expected',
-      fix: (fixer) => fixer.insertTextAfterRange([prevEnd, prevEnd], '\n'),
-    });
-
-    return;
-  }
-
-  if (!needBlank && blankCount > 0) {
-    const between = sourceCode.text.slice(prevEnd, currStart);
-    const indent = between.slice(between.lastIndexOf('\n') + 1);
-
-    context.report({
-      node: curr,
-      loc: curr.loc.start,
-      messageId: 'unexpected',
-      fix: (fixer) => fixer.replaceTextRange([prevEnd, currStart], `\n${indent}`),
-    });
-  }
-}
-
-export function processElementChildren(context, sourceCode, children, elementTypes, textType, offsetsOf) {
-  let run = [];
-
-  const flush = () => {
-    for (let i = 1; i < run.length; i += 1) {
-      reportElementPair(
-        context,
-        sourceCode,
-        run[i - 1],
-        run[i],
-        elementNeedsBlank(run[i - 2], run[i - 1], run[i]),
-        offsetsOf,
-      );
-    }
-
-    run = [];
-  };
-
-  for (const child of children) {
-    if (elementTypes.has(child.type)) {
-      run.push(child);
-    } else if (child.type === textType && (child.value || '').trim() === '') {
-      continue;
-    } else {
-      flush();
-    }
-  }
-
-  flush();
-}

package/eslint/vue.config.js

@@ -1,37 +0,0 @@
-/**
- * Vue ESLint configuration extending base config.
- * Requires the optional peer dependency `vue-eslint-parser`.
- * @param {Object} options - Configuration options
- * @returns {Array} ESLint flat config array
- */
-
-import tseslint from 'typescript-eslint';
-import vueParser from 'vue-eslint-parser';
-
-import { createBaseConfig } from './base.config.js';
-import { codexPlugin } from './plugin.js';
-
-export function createVueConfig(options = {}) {
-  const baseConfig = createBaseConfig(options);
-
-  const vueConfig = {
-    files: ['**/*.vue'],
-    languageOptions: {
-      parser: vueParser,
-      parserOptions: {
-        parser: tseslint.parser,
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-        extraFileExtensions: ['.vue'],
-      },
-    },
-    plugins: {
-      '@noxickon': codexPlugin,
-    },
-    rules: {
-      '@noxickon/blank-line-spacing': 'warn',
-    },
-  };
-
-  return [...baseConfig, vueConfig];
-}