@tuomashatakka/eslint-config 3.1.0 → 3.2.0

package/.github/workflows/publish.yml

@@ -2,7 +2,8 @@ name: Publish to npm
 
 on:
   push:
-    tags: ['v*']
+    branches: [main]
+    paths: ['package.json']
 
 jobs:
   publish:
@@ -12,34 +13,47 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: main
+          fetch-depth: 2
           token: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Detect version change
+        id: version
+        run: |
+          CURRENT=$(jq -r .version package.json)
+          PREVIOUS=$(git show HEAD~1:package.json 2>/dev/null | jq -r .version 2>/dev/null || echo "")
+          echo "CURRENT=$CURRENT" >> "$GITHUB_OUTPUT"
+          echo "PREVIOUS=$PREVIOUS" >> "$GITHUB_OUTPUT"
+          if [ "$CURRENT" != "$PREVIOUS" ] && [ -n "$CURRENT" ]; then
+            echo "CHANGED=true" >> "$GITHUB_OUTPUT"
+            echo "Version bumped: $PREVIOUS -> $CURRENT"
+          else
+            echo "CHANGED=false" >> "$GITHUB_OUTPUT"
+            echo "No version change ($CURRENT); skipping publish."
+          fi
+
       - uses: actions/setup-node@v4
+        if: steps.version.outputs.CHANGED == 'true'
         with:
           node-version: 22
           registry-url: https://registry.npmjs.org
           cache: npm
 
-      - name: Extract version from tag
-        id: version
-        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> "$GITHUB_OUTPUT"
-
-      - name: Sync package.json version with tag
-        run: npm version ${{ steps.version.outputs.VERSION }} --no-git-tag-version
+      - if: steps.version.outputs.CHANGED == 'true'
+        run: npm ci
 
-      - run: npm ci
-      - run: npm run test
+      - if: steps.version.outputs.CHANGED == 'true'
+        run: npm run test
 
       - name: Publish to npm
+        if: steps.version.outputs.CHANGED == 'true'
         run: npm publish --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-      - name: Commit version bump back to main
+      - name: Tag release
+        if: steps.version.outputs.CHANGED == 'true'
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add package.json package-lock.json
-          git commit -m "${{ steps.version.outputs.VERSION }}" || echo "No changes to commit"
-          git push origin main
+          git tag "v${{ steps.version.outputs.CURRENT }}"
+          git push origin "v${{ steps.version.outputs.CURRENT }}"

package/README.md

@@ -1,164 +1,110 @@
 # @tuomashatakka/eslint-config
 
-> Opinionated yet functional ESLint configuration with comprehensive TypeScript, React, and JSX support
+Opinionated ESLint flat config for TypeScript, React, and JSX projects. Bundles four in-house plugins (`whitespaced`, `omit`, `no-inline-types`, `react-strict`) on top of `@stylistic`, `typescript-eslint`, and `eslint-plugin-react`.
 
-For Next.js, React and TypeScript projects using modern flat config format.
+Requires ESLint 9.13+.
 
-## 🚀 Recent Updates (v2.5.0)
-
-### ✨ Major Improvements
-- **Removed Tailwind ESLint Plugin** - Streamlined configuration by removing tailwindcss plugin dependency
-- **Migrated React Rules to @stylistic/jsx** - Moved all React styling rules to the dedicated stylistic JSX plugin for better separation of concerns
-- **Updated All Plugins to Latest Versions** - Comprehensive dependency modernization with compatibility fixes
-- **Added Comprehensive Test Suite** - Complete test coverage for formatting scenarios and edge cases
-
-### 🔧 Technical Modernization
-- Updated `@stylistic/eslint-plugin` to v5.2.0
-- Added `@stylistic/eslint-plugin-jsx` for dedicated JSX formatting
-- Fixed deprecated `allowTemplateLiterals` configuration (migrated from boolean to 'always'/'never')
-- Consolidated plugin architecture for better maintainability
-
-## 📦 Installation
+## Installation
 
 ```bash
 npm install --save-dev @tuomashatakka/eslint-config
 ```
 
-## 🔧 Usage
+## Usage
 
-### Using the full config
+Create `eslint.config.mjs` in your project root.
 
-Create an `eslint.config.mjs` file in your project root:
+### Use the full config
 
-```javascript
+```js
 import config from '@tuomashatakka/eslint-config'
 
 export default config
 ```
 
-### Using just the rules
-
-If you want to use only the rules in your own config:
-
-```javascript
-import { rules } from '@tuomashatakka/eslint-config'
-
-export default [
-  // Your custom config here
-  {
-    // ...
-    rules
-  }
-]
-```
-
-### Custom Configuration
+### Extend or override
 
-```javascript
+```js
 import { baseConfig, rules } from '@tuomashatakka/eslint-config'
 
 export default [
   ...baseConfig,
   {
-    // Your custom overrides
     rules: {
       ...rules,
-      'no-console': 'off'
-    }
-  }
+      'no-console': 'off',
+    },
+  },
 ]
 ```
 
-## 🎯 Features
-
-### Code Quality Rules
-- **Complexity Control** - Max complexity: 14, max statements: 40
-- **Functional Patterns** - Encourages functional programming practices
-- **Type Safety** - Comprehensive TypeScript integration
-
-### Stylistic Formatting
-- **Consistent Spacing** - Aligned object properties, consistent indentation
-- **Modern Syntax** - Arrow functions, template literals, destructuring
-- **JSX Excellence** - Dedicated JSX formatting with proper component patterns
+### Use only the rules
 
-### Plugin Integration
-- **@stylistic/eslint-plugin** - Modern code formatting
-- **@stylistic/eslint-plugin-jsx** - JSX-specific formatting rules
-- **typescript-eslint** - TypeScript language support
-- **eslint-plugin-react** - React component best practices
-- **eslint-plugin-import** - Import/export management
-- **Custom Plugins** - Specialized rules for code quality
-
-## 🧪 Testing
-
-```bash
-# Run all tests
-npm run test
-
-# Test formatting capabilities
-npm run test:format
+```js
+import { rules } from '@tuomashatakka/eslint-config'
 
-# Lint the configuration itself
-npm run lint
+export default [{ rules }]
 ```
 
-### Test Coverage
-- ✅ Basic JavaScript patterns
-- ✅ Complex TypeScript scenarios  
-- ✅ React/JSX components
-- ✅ Edge cases and formatting challenges
-
-## 📋 Structure
+## Rules configuration
 
-The package uses ESLint's flat config format and has a clean structure:
+The config bundles four local plugins. Override any rule the same way you would override a standard ESLint rule.
 
-- `index.mjs` - Exports the full config, baseConfig, and rules
-- `rules.mjs` - Contains all the ESLint rules organized by category
-- `test/` - Comprehensive test suite with fixtures and runners
+### `whitespaced/*`
 
-## 🔍 Migration Guide
+| Rule | Description |
+| --- | --- |
+| `whitespaced/aligned-assignments` | Vertically aligns `=` in adjacent declaration and member-assignment blocks. |
+| `whitespaced/block-padding` | Enforces blank-line padding inside blocks, with docstring exceptions. |
+| `whitespaced/class-property-grouping` | Groups class properties by visibility and kind. |
+| `whitespaced/consistent-line-spacing` | Enforces consistent blank lines before and after statements. |
+| `whitespaced/multiline-format` | Enforces consistent formatting for multiline objects and arrays. |
 
-### From v2.4.0 to v2.5.0
+Options for `whitespaced/aligned-assignments`:
 
-1. **Remove tailwindcss dependency** (if manually installed)
-2. **Update package.json** - Latest versions are automatically handled
-3. **No breaking changes** - All existing code continues to work
-4. **Enhanced JSX support** - Better formatting for React components
+| Option | Type | Default | Effect |
+| --- | --- | --- | --- |
+| `blockSize` | integer | `2` | Minimum number of adjacent assignments before alignment applies. |
+| `ignoreAdjacent` | boolean | `true` | Only align rows on consecutive lines. |
+| `ignoreIfAssignmentsNotInBlock` | boolean | `true` | Split a group at every declaration-kind transition (`const` → `let`). Member assignments are wildcards and join any sub-block. |
+| `alignTypes` | boolean | `false` | Also align type-annotation colons. |
+| `ignoreTypesMismatch` | boolean | `true` | Skip colon alignment when only some rows have type annotations. |
+| `alignMemberAssignments` | boolean | `true` | Include `obj.prop = …` lines in alignment blocks alongside `const`/`let`/`var`. |
 
-### Deprecated Configurations
-- `allowTemplateLiterals: true` → `allowTemplateLiterals: 'always'`
-- Tailwind CSS rules removed (use dedicated Tailwind tools instead)
+### `omit/omit-unnecessary-parens-brackets`
 
-## 🐛 Troubleshooting
+Removes unnecessary parentheses, brackets, and braces. No options.
 
-### Common Issues
+### `no-inline-types/no-inline-multiline-types`
 
-**Template literal warnings:**
-- Update to v2.5.0+ for the fixed configuration
+Disallows inline multi-line `TSTypeLiteral` annotations; requires extraction to a named `type` or `interface`. No options.
 
-**JSX formatting issues:**
-- Ensure you're using files with proper extensions (.jsx, .tsx)
-- Check that React is properly detected in settings
+### `react-strict/*`
 
-**TypeScript parsing errors:**
-- Verify your tsconfig.json is valid
-- Ensure proper file extensions (.ts, .tsx)
+| Rule | Description |
+| --- | --- |
+| `react-strict/jsx-prop-layout` | Enforces JSX prop ordering: `key`/`ref`, then `className`/`style`, then `data-`/`aria-`, then regular props, callbacks last. |
+| `react-strict/no-complex-jsx-map` | Disallows complex `.map()` callbacks with inline logic inside JSX. |
+| `react-strict/no-jsx-value-calculations` | Disallows value calculations and assignments inside JSX return blocks. |
+| `react-strict/no-nested-divs` | Disallows nested `<div>` elements in favor of semantic HTML5 tags. |
+| `react-strict/no-style-prop` | Disallows the inline `style` prop except in drag/drop interactions. |
+| `react-strict/prefer-no-use-effect` | Discourages `useEffect` in favor of context, custom hooks, or event-driven patterns. |
 
-## 📈 Performance
+## Package structure
 
-- **Zero runtime dependencies** in production
-- **Fast linting** with optimized rule selection
-- **Minimal plugin surface area** for better performance
-- **Comprehensive but efficient** rule set
+- `index.mjs` — exports `config` (default), `baseConfig`, and `rules`.
+- `rules.mjs` — the rule map.
+- `plugins/` — local plugin sources.
+- `test/` — fixtures and runner.
 
-## 🤝 Contributing
+## Scripts
 
-1. Fork the repository
-2. Create a feature branch
-3. Add tests for new rules
-4. Run the test suite: `npm run test`
-5. Submit a pull request
+```bash
+npm run lint        # lint the config itself
+npm run test        # run all fixture tests
+npm run test:format # run formatting-only fixtures
+```
 
 ## License
 
-ISC
+ISC

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tuomashatakka/eslint-config",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Default eslint configuration",
   "type": "module",
   "main": "index.mjs",

package/plugins/omit/rules/omit-unnecessary-parens-brackets.mjs

@@ -2,7 +2,7 @@
  * @fileoverview Rule to omit unnecessary parentheses, brackets, and braces
  */
 
-import { isValidDotNotationIdentifier, isDeclaration, isParenthesized } from '../utils.mjs'
+import { isValidDotNotationIdentifier, isDeclaration, isParenthesized, statementCanAbsorbElse } from '../utils.mjs'
 
 
 export default {
@@ -160,13 +160,39 @@ function checkUnnecessaryBraces (blockStatement, controllingNode) {
       if (singleStatement.type === 'BlockStatement')
         return
 
+      // Dangling-else hazard: stripping the braces around an if/else if's
+      // consequent could let a trailing `else` rebind to a dangling inner
+      // `if`. Skip the fix entirely in that case.
+      const isConsequentOfIfWithElse =
+        controllingNode &&
+        controllingNode.type === 'IfStatement' &&
+        controllingNode.consequent === blockStatement &&
+        Boolean(controllingNode.alternate)
+
+      if (isConsequentOfIfWithElse && statementCanAbsorbElse(singleStatement))
+        return
+
+      // ASI hazard: when the next syntactic token after `}` is a keyword
+      // (`else` / `while` of a do-while), stripping the braces leaves the
+      // inner statement directly followed by that keyword on the same line.
+      // For statements that don't end with `;` or `}` in the source (e.g.
+      // `return x` inside a block where ASI fired at the closing brace),
+      // the result no longer parses. Detect this and either re-inject a `;`
+      // or skip the fix.
+      const tokenAfterBlock = sourceCode.getTokenAfter(blockStatement)
+      const needsAsiGuard =
+        tokenAfterBlock &&
+        tokenAfterBlock.type === 'Keyword' &&
+        (tokenAfterBlock.value === 'else' || tokenAfterBlock.value === 'while') &&
+        tokenAfterBlock.loc.start.line === blockStatement.loc.end.line
+
       context.report({
         node:      blockStatement,
         messageId: 'unnecessaryBraces',
         fix (fixer) {
           const firstToken = sourceCode.getFirstToken(blockStatement)
           const lastToken  = sourceCode.getLastToken(blockStatement)
-          const innerText  = sourceCode.getText(singleStatement)
+          let innerText    = sourceCode.getText(singleStatement)
 
           if (!firstToken || firstToken.value !== '{' || !lastToken || lastToken.value !== '}')
             return null
@@ -190,6 +216,12 @@ function checkUnnecessaryBraces (blockStatement, controllingNode) {
               return null
           }
 
+          if (needsAsiGuard) {
+            const trimmed = innerText.replace(/\s+$/, '')
+            if (!trimmed.endsWith(';') && !trimmed.endsWith('}'))
+              innerText = `${trimmed};`
+          }
+
           return fixer.replaceTextRange(blockStatement.range, innerText)
         },
       })

package/plugins/omit/utils.mjs

@@ -84,8 +84,37 @@ function isParenthesized (node, sourceCode) {
 }
 
 
+// Returns true when `stmt`, if placed where an `else` may follow, would
+// cause the trailing `else` to bind to an inner `if` instead of the outer
+// controlling node (the classic dangling-else hazard).
+export
+
+
+function statementCanAbsorbElse (stmt) {
+  if (!stmt)
+    return false
+
+  switch (stmt.type) {
+    case 'IfStatement':
+      if (!stmt.alternate)
+        return true
+      return statementCanAbsorbElse(stmt.alternate)
+    case 'ForStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'WhileStatement':
+    case 'WithStatement':
+    case 'LabeledStatement':
+      return statementCanAbsorbElse(stmt.body)
+    default:
+      return false
+  }
+}
+
+
 export default {
   isParenthesized,
   isDeclaration,
   isValidDotNotationIdentifier,
+  statementCanAbsorbElse,
 }

package/plugins/whitespaced/rules/aligned-assignments.mjs

@@ -31,12 +31,11 @@ export default {
       misalignedTypes:      'Type declarations should be vertically aligned within blocks.',
     },
   },
+
   create (context) {
     const sourceCode = context.sourceCode || context.getSourceCode()
     const options    = context.options[0] || {}
 
-    const alignComments                 = options.alignComments !== undefined ? options.alignComments : false
-    const alignLiterals                 = options.alignLiterals !== undefined ? options.alignLiterals : false
     const blockSize                     = options.blockSize !== undefined ? options.blockSize : 2
     const ignoreAdjacent                = options.ignoreAdjacent !== undefined ? options.ignoreAdjacent : true
     const ignoreIfAssignmentsNotInBlock = options.ignoreIfAssignmentsNotInBlock !== undefined ? options.ignoreIfAssignmentsNotInBlock : true
@@ -45,340 +44,278 @@ export default {
     const alignMemberAssignments        = options.alignMemberAssignments !== undefined ? options.alignMemberAssignments : true
 
 
-    function getEqualsColumn (declarator) {
-      const equalsToken = sourceCode.getTokenBefore(
-        declarator.init,
-        token => token.value === '='
-      )
-
-      return equalsToken ? equalsToken.loc.start.column : null
-    }
-
+    // ── Row collection ────────────────────────────────────────────────────
 
-    function getTypeColonColumn (declarator) {
-      if (declarator.id && declarator.id.typeAnnotation) {
-        const colonToken = sourceCode.getFirstToken(declarator.id.typeAnnotation)
-        return colonToken ? colonToken.loc.start.column : null
-      }
-      return null
+    function findEqualsToken (rightNode) {
+      return sourceCode.getTokenBefore(
+        rightNode,
+        token => token.type === 'Punctuator' && token.value === '='
+      )
     }
 
 
-    function areNodesAdjacent (node1, node2) {
-      return node2.loc.start.line === node1.loc.end.line + 1
+    function declaratorLhsEnd (declarator) {
+      const target = declarator.id?.typeAnnotation ?? declarator.id
+      return { col: target.loc.end.column, idx: target.range[1] }
     }
 
 
-    function haveSameKind (declarations) {
-      if (!declarations.length)
-        return true
+    function declaratorRow (declarator) {
+      if (!declarator.init)
+        return null
 
-      const firstKind = declarations[0].parent.kind
-      return declarations.every(decl => decl.parent.kind === firstKind)
-    }
+      const equalsToken = findEqualsToken(declarator.init)
 
+      if (!equalsToken)
+        return null
 
-    function allHaveTypes (declarations) {
-      return declarations.every(decl =>
-        decl.id && decl.id.typeAnnotation
-      )
-    }
-
+      const { col, idx } = declaratorLhsEnd(declarator)
 
-    function anyHaveTypes (declarations) {
-      return declarations.some(decl =>
-        decl.id && decl.id.typeAnnotation
-      )
+      return {
+        reportNode: declarator,
+        lhsEndCol:  col,
+        lhsEndIdx:  idx,
+        equalsToken,
+        line:       equalsToken.loc.start.line,
+        kind:       declarator.parent.kind,
+      }
     }
 
 
-    function getMaxEqualsColumn (declarations) {
-      return Math.max(...declarations.map(getEqualsColumn))
-    }
+    function memberAssignmentRow (stmt) {
+      const expr = stmt.expression
 
+      if (!expr || expr.type !== 'AssignmentExpression' || expr.operator !== '=' || expr.left.type !== 'MemberExpression')
+        return null
 
-    function getMaxTypeColonColumn (declarations) {
-      const columns = declarations
-        .map(getTypeColonColumn)
-        .filter(column => column !== null)
+      const equalsToken = findEqualsToken(expr.right)
 
-      return columns.length ? Math.max(...columns) : null
+      if (!equalsToken)
+        return null
+
+      return {
+        reportNode: expr,
+        lhsEndCol:  expr.left.loc.end.column,
+        lhsEndIdx:  expr.left.range[1],
+        equalsToken,
+        line:       equalsToken.loc.start.line,
+        kind:       'member',
+      }
     }
 
 
-function getFixedDeclaration (declarator, targetMaxEqualsColumn) {
-      const originalText = sourceCode.getText(declarator)
-      const idText = sourceCode.getText(declarator.id)
-      const initText = declarator.init ? sourceCode.getText(declarator.init) : ''
+    function collectRows (statements) {
+      const rows = []
 
-      if (!initText)
-        return originalText
+      for (const stmt of statements)
+        if (stmt.type === 'VariableDeclaration') {
+          for (const declarator of stmt.declarations) {
+            const row = declaratorRow(declarator)
+            if (row)
+              rows.push(row)
+          }
+        }
+        else if (alignMemberAssignments && stmt.type === 'ExpressionStatement') {
+          const row = memberAssignmentRow(stmt)
+          if (row)
+            rows.push(row)
+        }
 
-      // Get the equals token
-      const equalsToken = sourceCode.getTokenBefore(
-        declarator.init,
-        token => token.value === '='
-      )
+      return rows
+    }
 
-      if (!equalsToken)
-        return originalText
 
-      const currentEqualsColumn = equalsToken.loc.start.column
-      const padding = targetMaxEqualsColumn - currentEqualsColumn
+    // ── Adjacency grouping ────────────────────────────────────────────────
 
-      if (padding <= 0)
-        return originalText
+    function groupByAdjacency (rows) {
+      if (rows.length === 0)
+        return []
 
-      // Build the fixed text: id + padding + '= ' + init
-      const result = idText + ' '.repeat(padding) + '= ' + initText
+      const sorted = [ ...rows ].sort((a, b) => a.line - b.line)
+      const groups = []
+      let current  = [ sorted[0] ]
 
-      return result
-    }
+      for (let i = 1; i < sorted.length; i++) {
+        const prev = sorted[i - 1]
+        const row  = sorted[i]
 
+        if (ignoreAdjacent && row.line !== prev.line + 1) {
+          if (current.length >= blockSize)
+            groups.push(current)
+          current = []
+        }
 
-    function getIdLengthWithType (declarator) {
-      const idText = sourceCode.getText(declarator.id)
-      if (declarator.id && declarator.id.typeAnnotation) {
-        const typeText = sourceCode.getText(declarator.id.typeAnnotation)
-        return idText.length + 1 + typeText.length
+        current.push(row)
       }
-      return idText.length
-    }
 
+      if (current.length >= blockSize)
+        groups.push(current)
 
-    function checkAlignment (declarations) {
-      if (declarations.length < blockSize)
-        return
+      return ignoreAdjacent ? groups : (rows.length >= blockSize ? [ sorted ] : [])
+    }
 
-      if (ignoreIfAssignmentsNotInBlock && !haveSameKind(declarations))
-        return
 
-      // Get actual equals column positions
-      const equalsColumns = declarations.map(d => getEqualsColumn(d)).filter(c => c !== null)
+    // ── Kind-transition sub-block split ───────────────────────────────────
 
-      // Check if already aligned by comparing equals columns directly
-      if (equalsColumns.length >= 2) {
-        const maxEqualsCol = Math.max(...equalsColumns)
-        const minEqualsCol = Math.min(...equalsColumns)
-        if (maxEqualsCol === minEqualsCol)
-          return
-      }
+    function splitByKind (group) {
+      if (!ignoreIfAssignmentsNotInBlock)
+        return [ group ]
 
-      const maxIdLength = Math.max(...declarations.map(getIdLengthWithType))
+      const subBlocks = []
+      let current     = []
+      let lockedKind  = null
 
-      let maxTypeLength = null
-      if (alignTypes && anyHaveTypes(declarations)) {
-        if (ignoreTypesMismatch && !allHaveTypes(declarations)) {
-          // Skip only type alignment but still do equals alignment
+      for (const row of group)
+        if (row.kind === 'member')
+          current.push(row)
+        else if (lockedKind === null || lockedKind === row.kind) {
+          current.push(row)
+          lockedKind = row.kind
         }
         else {
-          const typeLengths = declarations
-            .map(d => d.id?.typeAnnotation ? sourceCode.getText(d.id.typeAnnotation).length : 0)
-            .filter(l => l > 0)
-          maxTypeLength = typeLengths.length ? Math.max(...typeLengths) : null
+          if (current.length >= blockSize)
+            subBlocks.push(current)
+          current    = [ row ]
+          lockedKind = row.kind
         }
-      }
 
-      const maxEqualsColumn = Math.max(...equalsColumns)
-
-      declarations.forEach(declarator => {
-        const equalsCol = getEqualsColumn(declarator)
-
-        if (equalsCol !== null && equalsCol !== maxEqualsColumn)
-          context.report({
-            node:      declarator,
-            messageId: 'misalignedAssignment',
-            fix (fixer) {
-              return fixer.replaceText(
-                declarator,
-                getFixedDeclaration(declarator, maxEqualsColumn)
-              )
-            },
-          })
-      })
-    }
+      if (current.length >= blockSize)
+        subBlocks.push(current)
 
+      return subBlocks
+    }
 
-    function processDeclarationGroup (declarations) {
-      if (!declarations.length)
-        return
 
-      const declarationsWithInits = declarations.filter(decl => decl.init)
+    // ── Alignment check + fix ─────────────────────────────────────────────
 
-      if (declarationsWithInits.length < blockSize)
+    function checkAndFix (subBlock) {
+      if (subBlock.length < blockSize)
         return
 
-      if (ignoreAdjacent) {
-        const adjacentGroups = []
-        let currentGroup = [ declarationsWithInits[0] ]
-
-        for (let i = 1; i < declarationsWithInits.length; i++) {
-          const prevDecl    = declarationsWithInits[i - 1]
-          const currentDecl = declarationsWithInits[i]
-
-          if (areNodesAdjacent(prevDecl, currentDecl))
-            currentGroup.push(currentDecl); else {
-            if (currentGroup.length >= blockSize)
-              adjacentGroups.push(currentGroup)
-            currentGroup = [ currentDecl ]
-          }
-        }
+      const targetEqualsCol = Math.max(...subBlock.map(r => r.lhsEndCol)) + 1
+      const allAligned      = subBlock.every(r => r.equalsToken.loc.start.column === targetEqualsCol)
 
-        if (currentGroup.length >= blockSize)
-          adjacentGroups.push(currentGroup)
+      if (allAligned)
+        return
 
-        adjacentGroups.forEach(checkAlignment)
+      for (const row of subBlock) {
+        const currentCol = row.equalsToken.loc.start.column
+
+        if (currentCol === targetEqualsCol)
+          continue
+
+        context.report({
+          node:      row.reportNode,
+          messageId: 'misalignedAssignment',
+          fix (fixer) {
+            const desiredPad = targetEqualsCol - row.lhsEndCol
+            if (desiredPad < 1)
+              return null
+            return fixer.replaceTextRange(
+              [ row.lhsEndIdx, row.equalsToken.range[0] ],
+              ' '.repeat(desiredPad)
+            )
+          },
+        })
       }
-      else
-        checkAlignment(declarationsWithInits)
     }
 
 
-    // ── Member assignment alignment (this.prop = value, obj.prop = value) ────
+    // ── Type colon alignment (orthogonal to equals alignment) ─────────────
 
-    function getMemberAssignEqualsColumn (exprStmt) {
-      const assignExpr  = exprStmt.expression
-      const equalsToken = sourceCode.getTokenBefore(
-        assignExpr.right,
-        token => token.value === '=' && token.type === 'Punctuator'
-      )
-      return equalsToken ? equalsToken.loc.start.column : null
+    function getTypeColonColumn (declarator) {
+      if (declarator.id && declarator.id.typeAnnotation) {
+        const colonToken = sourceCode.getFirstToken(declarator.id.typeAnnotation)
+        return colonToken ? colonToken.loc.start.column : null
+      }
+      return null
     }
 
 
-    function getFixedMemberAssignment (exprStmt, targetMaxLeftLength) {
-      const assignExpr = exprStmt.expression
-      const left       = assignExpr.left
-      const right      = assignExpr.right
-      const leftText   = sourceCode.getText(left)
-      const rightText  = sourceCode.getText(right)
-
-      const leftLength = leftText.length
-      const padding    = targetMaxLeftLength - leftLength
+    function checkTypeAlignment (declarators) {
+      if (!alignTypes || declarators.length < blockSize)
+        return
 
-      return leftText + ' '.repeat(padding) + '= ' + rightText
-    }
+      const annotated = declarators.filter(d => d.id?.typeAnnotation)
 
+      if (annotated.length < blockSize)
+        return
 
-    function getMemberLeftLength (exprStmt) {
-      const left = exprStmt.expression.left
-      return sourceCode.getText(left).trimEnd().length
-    }
+      if (ignoreTypesMismatch && annotated.length !== declarators.length)
+        return
 
+      const colonColumns = annotated.map(getTypeColonColumn).filter(c => c !== null)
 
-    function getMemberEqualsColumn (exprStmt) {
-      const assignExpr  = exprStmt.expression
-      const equalsToken = sourceCode.getTokenBefore(
-        assignExpr.right,
-        token => token.value === '=' && token.type === 'Punctuator'
-      )
-      return equalsToken ? equalsToken.loc.start.column : null
-    }
+      if (colonColumns.length < blockSize)
+        return
 
+      const maxColonCol = Math.max(...colonColumns)
+      const allAligned  = colonColumns.every(c => c === maxColonCol)
 
-    function checkMemberAlignment (stmts) {
-      if (stmts.length < blockSize)
+      if (allAligned)
         return
 
-      const lengths   = stmts.map(getMemberLeftLength)
-      const maxLength = Math.max(...lengths)
+      for (const declarator of annotated) {
+        const colonCol = getTypeColonColumn(declarator)
 
-      // Check if already aligned by comparing equals columns
-      const equalsColumns = stmts.map(s => getMemberEqualsColumn(s)).filter(c => c !== null)
-      if (equalsColumns.length >= 2) {
-        const maxCol     = Math.max(...equalsColumns)
-        const allAligned = equalsColumns.every(c => c === maxCol)
-        if (allAligned)
-          return
-      }
+        if (colonCol === null || colonCol === maxColonCol)
+          continue
 
-      stmts.forEach(stmt => {
-        const length = getMemberLeftLength(stmt)
-        if (length !== maxLength)
-          context.report({
-            node:      stmt.expression,
-            messageId: 'misalignedAssignment',
-            fix (fixer) {
-              return fixer.replaceText(stmt.expression, getFixedMemberAssignment(stmt, maxLength))
-            },
-          })
-      })
+        const colonToken = sourceCode.getFirstToken(declarator.id.typeAnnotation)
+        const idEndIdx   = declarator.id.range[1]
+        const desiredPad = maxColonCol - declarator.id.loc.end.column
+
+        if (desiredPad < 0)
+          continue
+
+        context.report({
+          node:      declarator,
+          messageId: 'misalignedTypes',
+          fix (fixer) {
+            return fixer.replaceTextRange(
+              [ idEndIdx, colonToken.range[0] ],
+              ' '.repeat(desiredPad)
+            )
+          },
+        })
+      }
     }
 
 
-    function processMemberAssignments (blockBody) {
-      if (!alignMemberAssignments)
-        return
-
-      const memberStmts = blockBody.filter(stmt =>
-        stmt.type === 'ExpressionStatement' &&
-        stmt.expression &&
-        stmt.expression.type === 'AssignmentExpression' &&
-        stmt.expression.operator === '=' &&
-        stmt.expression.left.type === 'MemberExpression'
-      )
+    // ── Block processor ───────────────────────────────────────────────────
 
-      if (memberStmts.length < blockSize)
+    function processStatements (statements) {
+      if (!statements || statements.length === 0)
         return
 
-      if (ignoreAdjacent) {
-        const groups = []
-        let group    = [ memberStmts[0] ]
-
-        for (let i = 1; i < memberStmts.length; i++)
-          if (areNodesAdjacent(memberStmts[i - 1], memberStmts[i]))
-            group.push(memberStmts[i])
-          else {
-            if (group.length >= blockSize)
-              groups.push(group)
-            group = [ memberStmts[i] ]
-          }
-        if (group.length >= blockSize)
-          groups.push(group)
-        groups.forEach(checkMemberAlignment)
-      }
-      else
-        checkMemberAlignment(memberStmts)
-    }
-
+      const rows = collectRows(statements)
 
-    // ── Shared block processor ─────────────────────────────────────────────
+      for (const group of groupByAdjacency(rows))
+        for (const subBlock of splitByKind(group))
+          checkAndFix(subBlock)
 
-    function processBlockVariables (node) {
-      const scopeBody    = node.type === 'Program' ? node.body : node.body ? node.body : []
-      const declarations = []
+      const declarators = []
+      for (const stmt of statements)
+        if (stmt.type === 'VariableDeclaration')
+          for (const declarator of stmt.declarations)
+            if (declarator.init)
+              declarators.push(declarator)
 
-      for (const statement of scopeBody)
-        if (statement.type === 'VariableDeclaration')
-          declarations.push(...statement.declarations)
-
-      processDeclarationGroup(declarations)
-      processMemberAssignments(scopeBody)
+      checkTypeAlignment(declarators)
     }
 
 
     return {
       Program (node) {
-        processBlockVariables(node)
+        processStatements(node.body)
       },
 
       BlockStatement (node) {
-        processBlockVariables(node)
+        processStatements(node.body)
       },
 
       SwitchCase (node) {
-        if (!node.consequent)
-          return
-
-        const declarations = []
-        const memberStmts  = []
-
-        for (const statement of node.consequent)
-          if (statement.type === 'VariableDeclaration')
-            declarations.push(...statement.declarations)
-
-        processDeclarationGroup(declarations)
-        processMemberAssignments(node.consequent)
+        processStatements(node.consequent)
       },
     }
   },

package/rules.mjs

@@ -41,7 +41,7 @@ export const rules = {
   'no-array-constructor':                      [ 'error' ],
   'omit/omit-unnecessary-parens-brackets':     [ 'warn' ],
   'no-inline-types/no-inline-multiline-types': [ 'warn' ],
-  'whitespaced/aligned-assignments':           [ 'warn', { alignMemberAssignments: false, alignTypes: true }],
+  'whitespaced/aligned-assignments':           [ 'warn', { alignTypes: true }],
   '@stylistic/function-call-spacing':          [ 'warn', 'never' ],
   '@stylistic/computed-property-spacing':      [ 'warn', 'never' ],
   '@stylistic/brace-style':                    [ 'warn', 'stroustrup', { allowSingleLine: false }],

package/test/fixtures/omit-braces-asi.invalid.ts

@@ -0,0 +1,6 @@
+// expect-warning: omit/omit-unnecessary-parens-brackets
+// Stripping these braces would produce `return 'x' else if (...) return 'red' else return null`
+// which is an ASI parse error. The autofix must inject `;` so the result still parses.
+export function pickColor (x: unknown): string | null {
+  if (x === true) { return 'x' } else if (x === 'blue') { return 'red' } else { return null }
+}

package/test/fixtures/omit-braces-hazards.valid.ts

@@ -0,0 +1,18 @@
+interface Material { uniforms: { time: { value: number }}}
+declare function isAnimatedShader (m: Material): boolean
+
+type MeshType = { material: Material | Material[] | null | undefined }
+
+
+// Dangling-else hazard: the outer braces are load-bearing — without
+// them, the trailing `else` would re-bind to `if (isAnimatedShader(m))`,
+// silently changing semantics. The omit rule must NOT flag these braces.
+export function update (mesh: MeshType, t: number) {
+  if (Array.isArray(mesh.material)) {
+    for (const m of mesh.material)
+      if (isAnimatedShader(m))
+        m.uniforms.time.value = t
+  }
+  else if (isAnimatedShader(mesh.material!))
+    mesh.material!.uniforms.time.value = t
+}

package/test/fixtures/whitespaced-members.valid.ts

@@ -8,6 +8,6 @@ class TestRunner {
 
   constructor () {
     this.fixturesDir = path.join('/test', 'fixtures')
-    this.configPath = path.join('/test', '../index.mjs')
+    this.configPath  = path.join('/test', '../index.mjs')
   }
 }

package/test/fixtures/whitespaced-mixed.invalid.ts

@@ -0,0 +1,68 @@
+// expect-warning: whitespaced/aligned-assignments
+
+
+type Bag = { texture: { colorSpace: string }, name: number, x: number, b: number, d: number, value: number }
+
+
+// Case 1: const + member assignment merged into one block.
+export function caseMergeBlock (bag: Bag) {
+  const texture = bag.texture
+  texture.colorSpace = 'srgb'
+  return texture
+}
+
+
+// Case 2: off-by-1 (the rebuild bug).
+export function caseOffByOne () {
+  const a = 1
+  const bb = 2
+  return a + bb
+}
+
+
+// Case 3: over-padded shorter row must shrink to match the longer row.
+export function caseShrink () {
+  const a              = 1
+  const longname = 2
+  return a + longname
+}
+
+
+// Case 4: kind transition splits the group into (const+member) and (let+member) sub-blocks.
+export function caseKindSplit (bag: Bag) {
+  const a = 1
+  bag.b = 2
+  let c = 3
+  bag.d = 4
+  c++
+  return a + c
+}
+
+
+// Case 5: TS type annotation must contribute to LHS-end, not just the identifier.
+export function caseTypeAnnotation () {
+  const aa: string = 'x'
+  const bb: number = 2
+  return aa + bb
+}
+
+
+// Case 6: computed and static member access mix.
+export function caseComputedMix (bag: Bag, key: 'name' | 'x') {
+  bag[key] = 1
+  bag.x = 2
+  return bag
+}
+
+
+// Case 7: inside SwitchCase.
+export function caseSwitch (n: number, bag: Bag) {
+  switch (n) {
+    case 1: {
+      const a = 1
+      bag.b = 2
+      return a
+    }
+  }
+  return 0
+}

package/test/fixtures/whitespaced-mixed.valid.ts

@@ -0,0 +1,66 @@
+type Bag = { texture: { colorSpace: string }, name: number, x: number, b: number, d: number, value: number }
+
+
+// Case 1: const + member assignment, aligned.
+export function caseMergeBlock (bag: Bag) {
+  const texture      = bag.texture
+  texture.colorSpace = 'srgb'
+  return texture
+}
+
+
+// Case 2: off-by-1 cleanly aligned.
+export function caseOffByOne () {
+  const a  = 1
+  const bb = 2
+  return a + bb
+}
+
+
+// Case 3: aligned (the long row dictates the target).
+export function caseShrink () {
+  const a        = 1
+  const longname = 2
+  return a + longname
+}
+
+
+// Case 4: kind-split groups, each sub-block aligned within itself.
+export function caseKindSplit (bag: Bag) {
+  const a = 1
+  bag.b   = 2
+
+  let c = 3
+  bag.d = 4
+  c++
+  return a + c
+}
+
+
+// Case 5: TS type annotation contributes to LHS-end (here naturally aligned).
+export function caseTypeAnnotation () {
+  const aa: string = 'x'
+  const bb: number = 2
+  return aa + bb
+}
+
+
+// Case 6: computed and static member access aligned.
+export function caseComputedMix (bag: Bag, key: 'name' | 'x') {
+  bag[key] = 1
+  bag.x    = 2
+  return bag
+}
+
+
+// Case 7: aligned inside SwitchCase.
+export function caseSwitch (n: number, bag: Bag) {
+  switch (n) {
+    case 1: {
+      const a = 1
+      bag.b   = 2
+      return a
+    }
+  }
+  return 0
+}