eslint-plugin-wyrm 0.0.6 → 0.0.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.0.7](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.6...eslint-plugin-wyrm-v0.0.7) (2025-11-05)
+
+
+### Bug Fixes
+
+* add distribute-boolean-casts ([a6a7a1d](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/a6a7a1d34fe2dca977bd98fb27337797ce1b1200))
+* add prefer-catch-method ([fb1b614](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/fb1b614f2a2e53c8e2ca197b706f458cbe73ba4a))
+
 ## [0.0.6](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.5...eslint-plugin-wyrm-v0.0.6) (2025-11-04)
 
 

package/README.md

@@ -49,21 +49,23 @@ export default defineConfig([
 💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\
 💭 Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
-| Name                                                                                                                                                                        | Description                                                     | 💼          | 🔧  | 💡  | 💭  |
-| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------- | :---------- | :-- | :-- | :-- |
-| [no-constant-template-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-constant-template-expression.md) | Disallow constant string expressions in template literals       | ☑️          |     | 💡  | 💭  |
-| [no-else-break](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-break.md)                                     | Forbid unnecessary `else` block after a `break` statement       | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
-| [no-else-continue](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-continue.md)                               | Forbid unnecessary `else` block after a `continue` statement    | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
-| [no-else-throw](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-throw.md)                                     | Forbid unnecessary `else` block after a `throw` statement       | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
-| [no-empty-comment](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-comment.md)                               | Forbid empty comments                                           | 🟪 ☑️       |     |     |     |
-| [no-empty-jsx-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-jsx-expression.md)                 | Forbid empty JSX expression containers                          | 🟩 ✅ 🟪 ☑️ |     |     |     |
-| [no-extra-nested-boolean-cast](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-extra-nested-boolean-cast.md)       | Forbid extra boolean casts in conditions and predicates         | 🟪 ☑️       |     |     |     |
-| [no-invalid-date-literal](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-invalid-date-literal.md)                 | Disallow invalid date literals                                  | 🟩 ✅ 🟪 ☑️ |     |     |     |
-| [no-jsx-statement](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-jsx-statement.md)                               | Forbid JSX expression statements                                | 🟩 ✅ 🟪 ☑️ |     |     |     |
-| [no-suspicious-jsx-semicolon](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-suspicious-jsx-semicolon.md)         | Forbid suspicious semicolons in JSX                             | 🟩 ✅ 🟪 ☑️ |     |     |     |
-| [no-ternary-return](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-ternary-return.md)                             | Disallow ternary conditions in return statements                | 🟪 ☑️       | 🔧  |     |     |
-| [no-useless-iife](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-useless-iife.md)                                 | Forbid useless IIFEs                                            | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
-| [prefer-repeat](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/prefer-repeat.md)                                     | Enforce usage of `String.prototype.repeat`                      | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
-| [unsafe-asserted-chain](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/unsafe-asserted-chain.md)                     | Disallow unsafe type assertions on optional chained expressions | ☑️          |     |     | 💭  |
+| Name                                                                                                                                                                        | Description                                                               | 💼          | 🔧  | 💡  | 💭  |
+| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------ | :---------- | :-- | :-- | :-- |
+| [distribute-boolean-casts](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/distribute-boolean-casts.md)               | Enforce that boolean casts are distributed over logical expressions       | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-constant-template-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-constant-template-expression.md) | Disallow constant string expressions in template literals                 | ☑️          |     | 💡  | 💭  |
+| [no-else-break](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-break.md)                                     | Forbid unnecessary `else` block after a `break` statement                 | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-else-continue](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-continue.md)                               | Forbid unnecessary `else` block after a `continue` statement              | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-else-throw](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-throw.md)                                     | Forbid unnecessary `else` block after a `throw` statement                 | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-empty-comment](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-comment.md)                               | Forbid empty comments                                                     | 🟪 ☑️       |     |     |     |
+| [no-empty-jsx-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-jsx-expression.md)                 | Forbid empty JSX expression containers                                    | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-extra-nested-boolean-cast](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-extra-nested-boolean-cast.md)       | Forbid extra boolean casts in conditions and predicates                   | 🟪 ☑️       |     |     |     |
+| [no-invalid-date-literal](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-invalid-date-literal.md)                 | Disallow invalid date literals                                            | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-jsx-statement](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-jsx-statement.md)                               | Forbid JSX expression statements                                          | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-suspicious-jsx-semicolon](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-suspicious-jsx-semicolon.md)         | Forbid suspicious semicolons in JSX                                       | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-ternary-return](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-ternary-return.md)                             | Disallow ternary conditions in return statements                          | 🟪 ☑️       | 🔧  |     |     |
+| [no-useless-iife](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-useless-iife.md)                                 | Forbid useless IIFEs                                                      | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
+| [prefer-catch-method](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/prefer-catch-method.md)                         | Enforce usage of `Promise.prototype.catch()` when it improves readability | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
+| [prefer-repeat](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/prefer-repeat.md)                                     | Enforce usage of `String.prototype.repeat`                                | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
+| [unsafe-asserted-chain](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/unsafe-asserted-chain.md)                     | Disallow unsafe type assertions on optional chained expressions           | ☑️          |     |     | 💭  |
 
 <!-- end auto-generated rules list -->

package/dist/rules/distribute-boolean-casts.d.ts

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint1 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/distribute-boolean-casts.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint1.RuleModule<"distributeBooleanCast", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint1.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/distribute-boolean-casts.js

@@ -0,0 +1,83 @@
+import { createRule } from "../utils/createRule.js";
+import { None, Some } from "../utils/option.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/distribute-boolean-casts.ts
+const { name } = path.parse(import.meta.filename);
+var distribute_boolean_casts_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce that boolean casts are distributed over logical expressions",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { distributeBooleanCast: "Distribute this boolean cast over logical expressions" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { LogicalExpression(node) {
+			if (node.operator === "??") return;
+			const parentCast = getParentBooleanCast(node);
+			if (!parentCast.some) return;
+			context.report({
+				node,
+				messageId: "distributeBooleanCast",
+				fix(fixer) {
+					const left = maybeWrapInBooleanCast(node.left);
+					const right = maybeWrapInBooleanCast(node.right);
+					const newText = `${left} ${node.operator} ${right}`;
+					return fixer.replaceText(parentCast.value, newText);
+				}
+			});
+		} };
+		function maybeWrapInBooleanCast(expr) {
+			const txt = context.sourceCode.getText(expr);
+			if (isBooleanLike(expr)) return txt;
+			return `!!(${txt})`;
+		}
+	}
+});
+function isBooleanLike(expr) {
+	if (expr.type === AST_NODE_TYPES.UnaryExpression) return expr.operator === "!";
+	if (expr.type === AST_NODE_TYPES.BinaryExpression) switch (expr.operator) {
+		case "&&":
+		case "||":
+		case "!=":
+		case "!==":
+		case "==":
+		case "===":
+		case "<":
+		case "<=":
+		case ">":
+		case ">=":
+		case "in":
+		case "instanceof": return true;
+		default: return false;
+	}
+	if (expr.type === AST_NODE_TYPES.Literal) return typeof expr.value === "boolean";
+	return false;
+}
+function getParentBooleanCast(node) {
+	if (!node.parent) return None;
+	if (node.parent.type === AST_NODE_TYPES.UnaryExpression && isDoubleNegation(node.parent)) return Some(node.parent.parent);
+	if (node.parent.type === AST_NODE_TYPES.CallExpression && isBooleanCall(node.parent)) return Some(node.parent);
+	return None;
+}
+function isDoubleNegation(node) {
+	if (node.operator !== "!") return false;
+	if (node.parent.type !== AST_NODE_TYPES.UnaryExpression) return false;
+	if (node.parent.operator !== "!") return false;
+	return true;
+}
+function isBooleanCall(node) {
+	if (node.callee.type !== AST_NODE_TYPES.Identifier) return false;
+	if (node.callee.name !== "Boolean") return false;
+	return true;
+}
+
+//#endregion
+export { distribute_boolean_casts_default as default };

package/dist/rules/index.d.ts

@@ -1,21 +1,23 @@
-import { _default } from "./no-constant-template-expression.js";
-import { _default as _default$1 } from "./no-else-break.js";
-import { _default as _default$2 } from "./no-else-continue.js";
-import { _default as _default$3 } from "./no-else-throw.js";
-import { _default as _default$4 } from "./no-empty-comment.js";
-import { _default as _default$5 } from "./no-empty-jsx-expression.js";
-import { _default as _default$6 } from "./no-extra-nested-boolean-cast.js";
-import { _default as _default$7 } from "./no-invalid-date-literal.js";
-import { _default as _default$8 } from "./no-jsx-statement.js";
-import { _default as _default$9 } from "./no-suspicious-jsx-semicolon.js";
-import { _default as _default$10 } from "./no-ternary-return.js";
-import { _default as _default$11 } from "./no-useless-iife.js";
-import { _default as _default$12 } from "./prefer-repeat.js";
-import { _default as _default$13 } from "./unsafe-asserted-chain.js";
+import { _default } from "./distribute-boolean-casts.js";
+import { _default as _default$1 } from "./no-constant-template-expression.js";
+import { _default as _default$2 } from "./no-else-break.js";
+import { _default as _default$3 } from "./no-else-continue.js";
+import { _default as _default$4 } from "./no-else-throw.js";
+import { _default as _default$5 } from "./no-empty-comment.js";
+import { _default as _default$6 } from "./no-empty-jsx-expression.js";
+import { _default as _default$7 } from "./no-extra-nested-boolean-cast.js";
+import { _default as _default$8 } from "./no-invalid-date-literal.js";
+import { _default as _default$9 } from "./no-jsx-statement.js";
+import { _default as _default$10 } from "./no-suspicious-jsx-semicolon.js";
+import { _default as _default$11 } from "./no-ternary-return.js";
+import { _default as _default$12 } from "./no-useless-iife.js";
+import { _default as _default$13 } from "./prefer-catch-method.js";
+import { _default as _default$14 } from "./prefer-repeat.js";
+import { _default as _default$15 } from "./unsafe-asserted-chain.js";
 
 //#region lib/rules/index.d.ts
 declare namespace index_d_exports {
-  export { _default as "no-constant-template-expression", _default$1 as "no-else-break", _default$2 as "no-else-continue", _default$3 as "no-else-throw", _default$4 as "no-empty-comment", _default$5 as "no-empty-jsx-expression", _default$6 as "no-extra-nested-boolean-cast", _default$7 as "no-invalid-date-literal", _default$8 as "no-jsx-statement", _default$9 as "no-suspicious-jsx-semicolon", _default$10 as "no-ternary-return", _default$11 as "no-useless-iife", _default$12 as "prefer-repeat", _default$13 as "unsafe-asserted-chain" };
+  export { _default as "distribute-boolean-casts", _default$1 as "no-constant-template-expression", _default$2 as "no-else-break", _default$3 as "no-else-continue", _default$4 as "no-else-throw", _default$5 as "no-empty-comment", _default$6 as "no-empty-jsx-expression", _default$7 as "no-extra-nested-boolean-cast", _default$8 as "no-invalid-date-literal", _default$9 as "no-jsx-statement", _default$10 as "no-suspicious-jsx-semicolon", _default$11 as "no-ternary-return", _default$12 as "no-useless-iife", _default$13 as "prefer-catch-method", _default$14 as "prefer-repeat", _default$15 as "unsafe-asserted-chain" };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -1,4 +1,5 @@
 import { __export } from "../_virtual/rolldown_runtime.js";
+import distribute_boolean_casts_default from "./distribute-boolean-casts.js";
 import no_constant_template_expression_default from "./no-constant-template-expression.js";
 import no_else_break_default from "./no-else-break.js";
 import no_else_continue_default from "./no-else-continue.js";
@@ -11,11 +12,13 @@ import no_jsx_statement_default from "./no-jsx-statement.js";
 import no_suspicious_jsx_semicolon_default from "./no-suspicious-jsx-semicolon.js";
 import no_ternary_return_default from "./no-ternary-return.js";
 import no_useless_iife_default from "./no-useless-iife.js";
+import prefer_catch_method_default from "./prefer-catch-method.js";
 import prefer_repeat_default from "./prefer-repeat.js";
 import unsafe_asserted_chain_default from "./unsafe-asserted-chain.js";
 
 //#region lib/rules/index.ts
 var rules_exports = /* @__PURE__ */ __export({
+	"distribute-boolean-casts": () => distribute_boolean_casts_default,
 	"no-constant-template-expression": () => no_constant_template_expression_default,
 	"no-else-break": () => no_else_break_default,
 	"no-else-continue": () => no_else_continue_default,
@@ -28,6 +31,7 @@ var rules_exports = /* @__PURE__ */ __export({
 	"no-suspicious-jsx-semicolon": () => no_suspicious_jsx_semicolon_default,
 	"no-ternary-return": () => no_ternary_return_default,
 	"no-useless-iife": () => no_useless_iife_default,
+	"prefer-catch-method": () => prefer_catch_method_default,
 	"prefer-repeat": () => prefer_repeat_default,
 	"unsafe-asserted-chain": () => unsafe_asserted_chain_default
 });

package/dist/rules/no-else-continue.d.ts

@@ -1,7 +1,7 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint1 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint5 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-else-continue.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint1.RuleModule<"noElseContinue", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint1.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint5.RuleModule<"noElseContinue", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint5.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-else-throw.d.ts

@@ -1,7 +1,7 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint3 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint7 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-else-throw.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint3.RuleModule<"noElseThrow", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint3.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint7.RuleModule<"noElseThrow", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint7.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-empty-comment.d.ts

@@ -1,9 +1,9 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint5 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint9 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-empty-comment.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint5.RuleModule<"noEmptyComment", [{
+declare const _default: _typescript_eslint_utils_ts_eslint9.RuleModule<"noEmptyComment", [{
   allowStacked: boolean;
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint5.RuleListener>;
+}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint9.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-empty-jsx-expression.d.ts

@@ -1,7 +1,7 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint7 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint11 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-empty-jsx-expression.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint7.RuleModule<"noEmptyJsxExpression", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint7.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint11.RuleModule<"noEmptyJsxExpression", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint11.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-empty-jsx-expression.js

@@ -38,6 +38,7 @@ var no_empty_jsx_expression_default = createRule({
 						return;
 					default: return;
 				}
+				if (node.parent.type === AST_NODE_TYPES.JSXAttribute) return;
 				context.report({
 					node,
 					messageId: "noEmptyJsxExpression"

package/dist/rules/no-extra-nested-boolean-cast.d.ts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint9 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint15 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-extra-nested-boolean-cast.d.ts
 
-declare const _default: _typescript_eslint_utils_ts_eslint9.RuleModule<"noExtraBooleanCastInCondition" | "noExtraBooleanCastInPredicate" | "noExtraBooleanCastInsideAnother", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint9.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint15.RuleModule<"noExtraBooleanCastInCondition" | "noExtraBooleanCastInPredicate" | "noExtraBooleanCastInsideAnother", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint15.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-invalid-date-literal.d.ts

@@ -1,7 +1,7 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint11 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint3 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-invalid-date-literal.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint11.RuleModule<"noInvalidDateLiteral", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint11.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint3.RuleModule<"noInvalidDateLiteral", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint3.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-invalid-date-literal.js

@@ -19,6 +19,8 @@ var no_invalid_date_literal_default = createRule({
 	create(context) {
 		return {
 			NewExpression(node) {
+				if (node.callee.type !== AST_NODE_TYPES.Identifier) return;
+				if (node.callee.name !== "Date") return;
 				if (node.arguments.length > 1) return;
 				const [arg] = node.arguments;
 				if (!arg) return;

package/dist/rules/no-suspicious-jsx-semicolon.d.ts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint15 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint17 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-suspicious-jsx-semicolon.d.ts
 
-declare const _default: _typescript_eslint_utils_ts_eslint15.RuleModule<"noSuspiciousJsxSemicolon" | "noSuspiciousJsxComma", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint15.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint17.RuleModule<"noSuspiciousJsxSemicolon" | "noSuspiciousJsxComma", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint17.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-ternary-return.d.ts

@@ -1,9 +1,10 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint17 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint25 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-ternary-return.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint17.RuleModule<"noTernaryReturn", [{
+
+declare const _default: _typescript_eslint_utils_ts_eslint25.RuleModule<"noTernaryReturn", [{
   allowSingleLine: boolean;
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint17.RuleListener>;
+}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint25.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/prefer-catch-method.d.ts

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint21 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/prefer-catch-method.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint21.RuleModule<"preferCatchMethod" | "useCatchMethod", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint21.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/prefer-catch-method.js

@@ -0,0 +1,121 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { ASTUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/prefer-catch-method.ts
+const { name } = path.parse(import.meta.filename);
+var prefer_catch_method_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce usage of `Promise.prototype.catch()` when it improves readability",
+			recommended: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			preferCatchMethod: "Prefer the `Promise.prototype.catch()` method to avoid imperative patterns",
+			useCatchMethod: "Replace by `.catch()`"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { TryStatement(node) {
+			const { block, handler, finalizer } = node;
+			if (!handler) return;
+			function hasReturnStatement(body) {
+				return body.some((stmt) => stmt.type === AST_NODE_TYPES.ReturnStatement);
+			}
+			function getAssignments(body) {
+				const assignments = [];
+				for (const stmt of body) {
+					if (stmt.type !== AST_NODE_TYPES.ExpressionStatement) continue;
+					if (stmt.expression.type !== AST_NODE_TYPES.AssignmentExpression) continue;
+					assignments.push(stmt.expression);
+				}
+				return assignments;
+			}
+			if (hasReturnStatement(handler.body.body)) return;
+			if (finalizer && hasReturnStatement(finalizer.body)) return;
+			const [firstBlockAssignment, ...otherBlockAssignments] = getAssignments(block.body);
+			if (!firstBlockAssignment) return;
+			if (firstBlockAssignment.right.type !== AST_NODE_TYPES.AwaitExpression) return;
+			if (otherBlockAssignments.some((assignment) => assignment.right.type === AST_NODE_TYPES.AwaitExpression)) return;
+			if (firstBlockAssignment.left.type !== AST_NODE_TYPES.Identifier) return;
+			const variableName = firstBlockAssignment.left.name;
+			const handlerAssignment = getAssignments(handler.body.body).find((assignment) => assignment.left.type === AST_NODE_TYPES.Identifier && assignment.left.name === variableName);
+			if (!handlerAssignment) return;
+			const scope = context.sourceCode.getScope(node);
+			const variable = ASTUtils.findVariable(scope, variableName);
+			if (!variable) return;
+			if (variable.scope !== scope) return;
+			const def = variable.defs.at(-1);
+			if (!def) return;
+			if (def.node.type !== AST_NODE_TYPES.VariableDeclarator) return;
+			if (def.node.parent.kind !== "let") return;
+			const decl = def.node;
+			if (variable.references.some((ref) => ref.isRead() && ref.identifier.range[1] < node.range[0])) return;
+			const indent = " ".repeat(node.loc.start.column + 2);
+			const indent2 = `${indent}${" ".repeat(2)}`;
+			function isNameInScope(identifierName, currentScope = context.sourceCode.getScope(block)) {
+				if (currentScope.variables.some((v) => v.name === identifierName)) return true;
+				if (!currentScope.upper) return false;
+				return isNameInScope(identifierName, currentScope.upper);
+			}
+			function getFreeVariableName(n = 0) {
+				const identifierName = `val${n}`;
+				if (isNameInScope(identifierName)) return getFreeVariableName(n + 1);
+				return identifierName;
+			}
+			function getAwaitThenExpression() {
+				if (!firstBlockAssignment) return "";
+				const awaitExpression = context.sourceCode.getText(firstBlockAssignment.right);
+				const otherStatements = block.body.filter((stmt) => stmt.type !== AST_NODE_TYPES.ExpressionStatement || stmt.expression !== firstBlockAssignment);
+				if (!otherStatements.length) return awaitExpression;
+				const statementsText = otherStatements.map((stmt) => context.sourceCode.getText(stmt)).join(`\n${indent2}`);
+				const resultParamName = getFreeVariableName();
+				return `${awaitExpression}
+${indent}.then((${resultParamName}) => {
+${indent2}${statementsText}
+${indent2}return ${resultParamName};
+${indent}})`;
+			}
+			function getErrorParameter() {
+				if (!handler) return "";
+				const { param } = handler;
+				if (!param) return "";
+				const paramText = context.sourceCode.getText(param);
+				if (param.typeAnnotation) return paramText;
+				return `${paramText}: unknown`;
+			}
+			function getHandlerText() {
+				if (!handler) return "";
+				if (!handlerAssignment) return "";
+				const handlerAssignmentText = `${indent}return ${context.sourceCode.getText(handlerAssignment.right)};`;
+				const statements = handler.body.body.filter((stmt) => stmt.type !== AST_NODE_TYPES.ExpressionStatement || stmt.expression !== handlerAssignment);
+				if (!statements.length) return handlerAssignmentText;
+				return `${indent}${statements.map((stmt) => context.sourceCode.getText(stmt)).join(`\n${indent2}`)}\n${indent}${handlerAssignmentText}`;
+			}
+			context.report({
+				node,
+				messageId: "preferCatchMethod",
+				suggest: [{
+					messageId: "useCatchMethod",
+					*fix(fixer) {
+						if (decl.parent.declarations.length > 1) yield fixer.remove(decl);
+						else yield fixer.remove(decl.parent);
+						const errorParam = getErrorParameter();
+						const handlerText = getHandlerText();
+						const awaitThenExpression = getAwaitThenExpression();
+						yield fixer.remove(node);
+						yield fixer.insertTextBefore(node, `let ${variableName} = ${awaitThenExpression}\n${indent}.catch((${errorParam}) => {\n  ${handlerText}\n  });`);
+					}
+				}]
+			});
+		} };
+	}
+});
+
+//#endregion
+export { prefer_catch_method_default as default };

package/dist/rules/prefer-repeat.d.ts

@@ -1,7 +1,7 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint21 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint23 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/prefer-repeat.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint21.RuleModule<"preferRepeat" | "replaceByRepeat", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint21.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint23.RuleModule<"preferRepeat" | "replaceByRepeat", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint23.RuleListener>;
 //#endregion
 export { _default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-wyrm",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Some custom ESLint rules",
   "keywords": [
     "eslint",