eslint-plugin-smarthr 3.4.0 → 3.5.1

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [3.5.1](https://github.com/kufu/tamatebako/compare/eslint-plugin-smarthr-v3.5.0...eslint-plugin-smarthr-v3.5.1) (2025-12-31)
+
+
+### Bug Fixes
+
+* best-practice-for-rest-parameters で残余引数をarrow functionでreturnする場合誤検知されていた問題を修正 ([#988](https://github.com/kufu/tamatebako/issues/988)) ([4353323](https://github.com/kufu/tamatebako/commit/4353323e1cc37761dbc841023f5b1575ca3e38cc))
+* best-practice-for-rest-parameters で残余引数をreturnする場合誤検知されていた問題を修正 ([#986](https://github.com/kufu/tamatebako/issues/986)) ([9ff646c](https://github.com/kufu/tamatebako/commit/9ff646c10c6ca9c28eff111b837fa6030003ac2a))
+
+## [3.5.0](https://github.com/kufu/tamatebako/compare/eslint-plugin-smarthr-v3.4.0...eslint-plugin-smarthr-v3.5.0) (2025-12-26)
+
+
+### Features
+
+* smarthr/best-practice-for-optional-chaining を追加 ([#979](https://github.com/kufu/tamatebako/issues/979)) ([ff18a55](https://github.com/kufu/tamatebako/commit/ff18a55970f026c2d828cf22f99e9969d90d7d82))
+* smarthr/best-practice-for-unnesessary-early-return を追加 ([#977](https://github.com/kufu/tamatebako/issues/977)) ([cd0b1a2](https://github.com/kufu/tamatebako/commit/cd0b1a205e82f01ce2be4fe43b69555d86ab5fd1))
+
 ## [3.4.0](https://github.com/kufu/tamatebako/compare/eslint-plugin-smarthr-v3.3.2...eslint-plugin-smarthr-v3.4.0) (2025-12-24)
 
 

package/README.md

@@ -21,11 +21,13 @@
 - [best-practice-for-date](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-date)
 - [best-practice-for-layouts](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-layouts)
 - [best-practice-for-nested-attributes-array-index](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-nested-attributes-array-index)
+- [best-practice-for-optional-chaining](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-optional-chaining)
 - [best-practice-for-prohibit-import-smarthr-ui-local](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-prohibit-import-smarthr-ui-local)
 - [best-practice-for-remote-trigger-dialog](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-remote-trigger-dialog)
 - [best-practice-for-rest-parameters](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-rest-parameters)
 - [best-practice-for-tailwind-prohibit-root-margin](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-tailwind-prohibit-root-margin)
 - [best-practice-for-tailwind-variants](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-tailwind-variants)
+- [best-practice-for-unnesessary-early-return](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return)
 - [design-system-guideline-prohibit-double-icons](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/design-system-guideline-prohibit-double-icons)
 - [format-import-path](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/format-import-path)
 - [format-translate-component](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/format-translate-component)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-smarthr",
-  "version": "3.4.0",
+  "version": "3.5.1",
   "author": "SmartHR",
   "license": "MIT",
   "description": "A sharable ESLint plugin for SmartHR",
@@ -26,7 +26,7 @@
     "json5": "^2.2.3"
   },
   "devDependencies": {
-    "typescript-eslint": "^8.50.0"
+    "typescript-eslint": "^8.50.1"
   },
   "peerDependencies": {
     "eslint": "^9"
@@ -37,5 +37,5 @@
     "eslintplugin",
     "smarthr"
   ],
-  "gitHead": "25b508c89653cc0e754e091f83d8b31346afb08e"
+  "gitHead": "ca09d161140518cc79de3365fab83b93ff883da7"
 }

package/rules/best-practice-for-optional-chaining/README.md

@@ -0,0 +1,75 @@
+# smarthr/best-practice-for-optional-chaining
+
+- optional chaining(xxx?.yyy記法)を使うことを促すルールです
+
+## rules
+
+```js
+{
+  rules: {
+    'smarthr/best-practice-for-optional-chaining': 'error', // 'warn', 'off'
+  },
+}
+```
+
+## ❌ Incorrect
+
+```jsx
+if (action) action()
+```
+
+```jsx
+if (obj.action) {
+  obj.action(hoge, fuga)
+}
+```
+
+
+## ✅ Correct
+
+```jsx
+action?.()
+```
+
+```jsx
+obj.action?.(hoge, fuga)
+```
+
+```jsx
+// 実行する関数と無関係の条件の場合は許容
+if (any) {
+  action()
+}
+```
+
+```jsx
+// 実行する関数の存在チェック以外が条件に含まれている場合は許容
+if (action && any) {
+  action()
+}
+```
+
+```jsx
+// if - else などifに他条件が連なる場合は許容
+if (action) {
+  action()
+} else {
+  ...
+}
+```
+
+```jsx
+// if内で関数呼び出し以外の処理が存在すれば許容
+if (action) {
+  return action()
+}
+```
+
+```jsx
+// else if内の場合は許容
+if (any) {
+  ...
+} else if (action) {
+  action()
+}
+```

package/rules/best-practice-for-optional-chaining/index.js

@@ -0,0 +1,40 @@
+const SCHEMA = []
+
+const REPLACABLE_CALLEE = `[consequent.expression.callee.type='Identifier']`
+const WITHOUT_BODY_IF_ID = `[test.type='Identifier']${REPLACABLE_CALLEE}`
+const WITH_BODY_IF_ID = WITHOUT_BODY_IF_ID.replace(REPLACABLE_CALLEE, "[consequent.body.length=1][consequent.body.0.expression.callee.type='Identifier']")
+const SELECTOR = `IfStatement[alternate=null]:not([parent.type='IfStatement']):matches(${WITHOUT_BODY_IF_ID},${WITHOUT_BODY_IF_ID.replaceAll("'Identifier'", "'MemberExpression'")},${WITH_BODY_IF_ID},${WITH_BODY_IF_ID.replaceAll("'Identifier'", "'MemberExpression'")})`
+
+
+/**
+ * @type {import('@typescript-eslint/utils').TSESLint.RuleModule<''>}
+ */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    schema: SCHEMA,
+  },
+  create(context) {
+    return {
+      [SELECTOR]: (node) => {
+        const expression = node.consequent.expression || node.consequent.body[0].expression
+        const calleName = context.sourceCode.getText(expression.callee)
+
+        if (context.sourceCode.getText(node.test) === calleName) {
+          context.report({
+            node,
+            message: `optional chaining(xxx?.yyyy記法)を利用してください
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-optional-chaining`,
+            fix: (fixer) => fixer.replaceText(
+              node,
+              context.sourceCode.getText(expression).replace(new RegExp(`^${calleName}\\(`), `${calleName}\?\.(`),
+            ),
+          })
+        }
+      },
+    }
+  },
+}
+module.exports.schema = SCHEMA
+

package/rules/best-practice-for-rest-parameters/README.md

@@ -1,6 +1,6 @@
 # smarthr/best-practice-for-rest-parameters
 
-- 残余引数(rest parameters)の命名規則を設定するルールです
+- 残余引数(rest parameters)の利用方法を設定するルールです
   - https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Functions/rest_parameters
 - 残余引数にはrestという名称を設定することを推奨します
   - よく利用される `props` などを利用するとエラーになります

package/rules/best-practice-for-rest-parameters/index.js

@@ -47,9 +47,14 @@ module.exports = {
           message: `残余引数には ${REST_REGEX} とマッチする名称を指定してください${DETAIL_LINK}`,
         })
       },
-      [`:not(:matches(RestElement,JSXSpreadAttribute,JSXSpreadAttribute>TSAsExpression,SpreadElement,SpreadElement>TSAsExpression,MemberExpression,VariableDeclarator,ArrayExpression,CallExpression,ObjectPattern>Property,ObjectExpression>Property))>Identifier[name=${REST_REGEX}]`]: actionNotRest,
+      [`:not(:matches(RestElement,JSXSpreadAttribute,JSXSpreadAttribute>TSAsExpression,SpreadElement,SpreadElement>TSAsExpression,MemberExpression,VariableDeclarator,ArrayExpression,CallExpression,ObjectPattern>Property,ObjectExpression>Property,ReturnStatement,ArrowFunctionExpression))>Identifier[name=${REST_REGEX}]`]: actionNotRest,
       [`:matches(VariableDeclarator[id.name=${REST_REGEX}],ObjectPattern>Property[value.name=${REST_REGEX}],ObjectExpression>Property[key.name=${REST_REGEX}])`]: actionNotRest,
       [`MemberExpression[object.name=${REST_REGEX}]`]: actionMemberExpressionName,
+      [`ArrowFunctionExpression>Identifier[name=${REST_REGEX}]`]: (node) => {
+        if (node !== node.parent.body) {
+          actionNotRest(node)
+        }
+      },
       [`VariableDeclarator[id.type='ObjectPattern'][init.name=${REST_REGEX}]`]: (node) => {
         context.report({
           node,

package/rules/best-practice-for-unnesessary-early-return/README.md

@@ -0,0 +1,161 @@
+# smarthr/best-practice-for-unnesessary-early-return
+
+- 不必要な早期returnをチェックするルールです
+- 不要な早期returnとは **直後に実行される処理の条件を逆転している早期return** を指します
+
+```jsx
+// 不要な早期returnの例
+const anyAction = (a) => {
+  if (!a) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+- 上記の例の場合、実質 `otherActionを実行する条件だけが存在する` ため、実際にコードを読む際、条件を逆転させて考える余計なコストが発生します
+- 下記の様に早期returnを利用せず書くことを推奨します
+
+
+```jsx
+const anyAction = (a) => {
+  if (a) {
+    otherAction()
+  }
+}
+```
+
+- 上記のような条件に修正することで、本質的に実行したい処理の条件がわかりやすくなります
+- このルールは以下の条件すべてに合致する場合、NGにします
+  - 早期return以降にifやelse、switch, tryがない
+  - 早期returnの条件ブロック以降に変数宣言がない
+  - 早期returnの条件ブロック以降にreturnがない
+  - 早期returnが値を返していない
+
+## rules
+
+```js
+{
+  rules: {
+    'smarthr/best-practice-for-unnesessary-early-return': 'error', // 'warn', 'off'
+  },
+}
+```
+
+## ❌ Incorrect
+
+```jsx
+const anyAction = (a) => {
+  // otherActionの実行条件を逆転させているだけのためNG
+  if (!a) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+```jsx
+const anyAction = (a, b) => {
+  // 早期returnの条件内容自体は無関係にチェックするためNG
+  if (!a || !b) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+```jsx
+const anyAction = (a, b) => {
+  switch (a) {
+    ...
+  }
+
+  // 早期returnより前に条件などがあっても、条件が実質逆転しているためNG
+  if (!b) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+```jsx
+const anyAction = (a, b) => {
+  if (!a) {
+    return
+  }
+  // 早期returnが分割されているため、前述の早期returnの条件とまとめるべきなのでNG
+  if (!b) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+## ✅ Correct
+
+```jsx
+const anyAction = (a) => {
+  if (a) {
+    otherAction()
+  }
+}
+```
+
+```jsx
+// 許容する早期returnの例
+const sample1 = (a) => {
+  if (a) {
+    // 早期returnで値を返しているため許容
+    return true
+  }
+  ...
+}
+
+const sample2 = (a) => {
+  if (!a) {
+    return
+  }
+
+  // 早期return後に変数宣言しているため許容
+  const caculated = calc(a)
+  ...
+}
+
+const sample3 = (a) => {
+  if (!a) {
+    return
+  }
+  // 早期returnの条件以外に条件が存在するため許容
+  else if (a === any) {
+    ...
+  }
+}
+
+const sample4 = (a, b) => {
+  if (!a) {
+    return
+  }
+
+  otherAction1(a)
+
+  // この場合も別条件のため許容
+  if (b === any) {
+    return
+  }
+  ...
+}
+
+const sample5 = (a, b) => {
+  if (!a) {
+    return
+  }
+
+  // 早期returnとは別のreturnが関数スコープのrootにあるため許容
+  return ...
+}
+```

package/rules/best-practice-for-unnesessary-early-return/index.js

@@ -0,0 +1,92 @@
+const SCHEMA = []
+
+const EARLY_RETURN_IF_STATEMENT = `:matches(ArrowFunctionExpression,FunctionExpression,FunctionDeclaration)>BlockStatement>IfStatement[alternate=null]:matches([consequent.type='ReturnStatement'],[consequent.body.length=1])>`
+const NULL_RETURN_STATEMENT = 'ReturnStatement[argument=null]'
+
+const FUNCTION_REGEX = /^(Arrow)?Function(Expression|Declaration)$/
+
+const searchFunction = (node) => FUNCTION_REGEX.test(node.type) ? node : searchFunction(node.parent)
+
+const getEarlyReturn = (b) => {
+  let ret = null
+  switch (b.consequent.type) {
+    case 'ReturnStatement':
+      ret = b.consequent
+
+      break
+    case 'BlockStatement':
+      if (b.consequent.body.length === 1 && b.consequent.body[0].type === 'ReturnStatement') {
+        ret = b.consequent.body[0]
+      }
+
+      break
+  }
+
+  return ret?.argument === null ? ret : null
+}
+
+const DETAIL_LINK = `
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return`
+
+/**
+ * @type {import('@typescript-eslint/utils').TSESLint.RuleModule<''>}
+ */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    schema: SCHEMA,
+  },
+  create(context) {
+    const action = (node) => {
+      const fn = searchFunction(node).body.body
+      // 0: 最初の早期returnを検索中
+      // 1: 最初の早期returnを発見、その後も連続して早期returnが存在する場合
+      // 2: 1の後、早期returnの連続が途切れた場合
+      let flg = 0
+
+      for (let i = 0; i < fn.length; i++) {
+        const b = fn[i]
+
+        if (!flg) {
+          if (b.type === 'IfStatement' && getEarlyReturn(b)) {
+            flg = 1
+          }
+
+          continue
+        }
+
+        switch (b.type) {
+          case 'VariableDeclaration':
+          case 'ReturnStatement':
+          case 'SwitchStatement':
+          case 'TryStatement':
+            return
+          case 'IfStatement':
+            if (flg === 1 && node === getEarlyReturn(b)) {
+              context.report({
+                node,
+                message: `早期returnのifが分割されています${DETAIL_LINK}
+ - 一つのifにまとめるよう、条件を調整してください`,
+              })
+            }
+            return
+        }
+
+        flg = 2
+      }
+
+      context.report({
+        node,
+        message: `後続の処理の逆の条件の早期returnのため修正してください。${DETAIL_LINK}
+ - 本質的に行いたい処理の条件とは逆がifに記述されているため、ロジックを確認する際条件を逆転させて考える余計な手間が発生しています
+ - 条件を逆転させたうえで後続の処理をifの内部に移動してください`,
+      })
+    }
+
+    return {
+      [`${EARLY_RETURN_IF_STATEMENT}BlockStatement>${NULL_RETURN_STATEMENT}`]: action,
+      [`${EARLY_RETURN_IF_STATEMENT}${NULL_RETURN_STATEMENT}`]: action,
+    }
+  },
+}
+module.exports.schema = SCHEMA

package/test/best-practice-for-optional-chaining.js

@@ -0,0 +1,48 @@
+const rule = require('../rules/best-practice-for-optional-chaining')
+const RuleTester = require('eslint').RuleTester
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+})
+
+const ERROR = `optional chaining(xxx?.yyyy記法)を利用してください
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-optional-chaining`
+
+ruleTester.run('best-practice-for-optional-chaining', rule, {
+  valid: [
+    { code: `action?.()` },
+    { code: `obj.action?.(hoge, fuga)` },
+    { code: `if (any) { action() }` },
+    { code: `if (action && any) { action() }` },
+    { code: `if (action) { action() } else { any() }` },
+    { code: `if (obj.hoge) obj.hoge.fuga.action()` },
+    { code: `() => { if (action) return action() }` },
+    { code: `if (any) {} else if (action) { action() }` },
+  ],
+  invalid: [
+    { code: `if (action) action()`, errors: [{ message: ERROR }], output: 'action?.()' },
+    { code: `if (obj.action) { obj.action(hoge, fuga) }`, errors: [{ message: ERROR }], output: 'obj.action?.(hoge, fuga)' },
+    { code: `if (obj.hoge.fuga.action) obj.hoge.fuga.action()`, errors: [{ message: ERROR }], output: 'obj.hoge.fuga.action?.()' },
+    { code: `
+      if (obj.hoge.fuga.action) {
+        obj.hoge.fuga.action(
+          a,
+          b,
+          c
+        )
+      }
+    `, errors: [{ message: ERROR }], output: `
+      obj.hoge.fuga.action?.(
+          a,
+          b,
+          c
+        )
+    ` },
+  ],
+})

package/test/best-practice-for-rest-parameters.js

@@ -32,6 +32,13 @@ ruleTester.run('best-practice-for-rest-parameters', rule, {
     { code: `const hoge = [rest]` },
     { code: `hoge(fugaRest)` },
     { code: `<Any {...rest} />` },
+    { code: `
+      const removeKey = (key, obj) => {
+        const { [key]: _removed, ...rest } = obj
+        return rest
+      }
+    ` },
+    { code: `const removeIdAttr = ({ id: _id, ...rest }) => rest` },
   ],
   invalid: [
     { code: `const hoge = ({ ...rest }) => {}`, errors: [ { message: `意味のない残余引数のため、単一の引数に変更してください${DETAIL_LINK}` } ] },

package/test/best-practice-for-unnesessary-early-return.js

@@ -0,0 +1,189 @@
+const rule = require('../rules/best-practice-for-unnesessary-early-return')
+const RuleTester = require('eslint').RuleTester
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+})
+
+const UNNESESSARY_EARLY_RETURN_ERROR = `後続の処理の逆の条件の早期returnのため修正してください。
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return
+ - 本質的に行いたい処理の条件とは逆がifに記述されているため、ロジックを確認する際条件を逆転させて考える余計な手間が発生しています
+ - 条件を逆転させたうえで後続の処理をifの内部に移動してください`
+const SPLIT_EARLY_RETURN_ERROR = `早期returnのifが分割されています
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return
+ - 一つのifにまとめるよう、条件を調整してください`
+
+ruleTester.run('best-practice-for-unnesessary-early-return', rule, {
+  valid: [
+    { code: `
+      const anyAction = (a) => {
+        if (a) {
+          otherAction()
+        }
+      }
+    ` },
+    { code: `
+      const sample2 = (a) => {
+        if (!a) return
+
+        const caculated = calc(a)
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        } else {
+        }
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        } else if (any) {
+        }
+      }
+    ` },
+    { code: `
+      const sample4 = (a, b) => {
+        if (!a) {
+          return
+        }
+
+        otherAction1(a)
+
+        if (b === any) {
+          return
+        }
+
+        otherAction2(b)
+      }
+    ` },
+    { code: `
+      const sample4 = (a, b) => {
+        if (!a) {
+          return
+        }
+
+        switch(a) {
+          case 'hoge':
+            break
+        }
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          otherAction1()
+          return
+        }
+
+        otherAction2()
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        }
+
+        return otherAction2()
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        }
+
+        try {
+          otherAction()
+        } catch {
+        }
+      }
+    ` },
+  ],
+  invalid: [
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a) => {
+        const hoge = any
+
+        if (!a) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        if (!a || !b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        switch (a) {
+          case 'hoge':
+            break
+        }
+
+        if (!b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        // 早期returnより前に非早期returnのif,switchがある場合
+        if (a && b) {
+          return 'hoge'
+        }
+
+        // 早期return後にswitchがある場合強制終了されるが
+        // このswitchは早期return前のため後続でエラーになる
+        switch (a) {
+          case 'hoge':
+            break
+        }
+
+        if (!b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        if (!a) return
+        if (!b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ SPLIT_EARLY_RETURN_ERROR ] },
+  ]
+})