@tuomashatakka/eslint-config 3.1.0 → 3.1.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tuomashatakka/eslint-config",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "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/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
+}