eslint-plugin-wyrm 0.0.5 → 0.0.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [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)
+
+
+### Bug Fixes
+
+* add no-else-break and no-else-continue ([eb2647f](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/eb2647feb3a5d04782a86db8324259afb70a5369))
+* add no-else-throw ([cedc18e](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/cedc18efd6952c3c3195d378dbd59a8772b7613d))
+
 ## [0.0.5](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.4...eslint-plugin-wyrm-v0.0.5) (2025-11-02)
 
 

package/README.md

@@ -52,11 +52,18 @@ export default defineConfig([
 | 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 | ☑️          |     |     | 💭  |
 
 <!-- end auto-generated rules list -->

package/dist/configs/index.js

@@ -38,7 +38,7 @@ const strictOnly = createConfigWithRules(rules_exports, "strictOnly", (rule) =>
 });
 const strict = {
 	...baseConfig,
-	name: `wyrm/strict`,
+	name: "wyrm/strict",
 	rules: {
 		...recommended.rules,
 		...strictOnly.rules
@@ -51,7 +51,7 @@ const recommendedTypeCheckedOnly = createConfigWithRules(rules_exports, "recomme
 });
 const recommendedTypeChecked = {
 	...baseConfig,
-	name: `wyrm/recommendedTypeChecked`,
+	name: "wyrm/recommendedTypeChecked",
 	rules: {
 		...recommended.rules,
 		...recommendedTypeCheckedOnly.rules
@@ -64,7 +64,7 @@ const strictTypeCheckedOnly = createConfigWithRules(rules_exports, "strictTypeCh
 });
 const strictTypeChecked = {
 	...baseConfig,
-	name: `wyrm/strictTypeChecked`,
+	name: "wyrm/strictTypeChecked",
 	rules: {
 		...recommendedTypeChecked.rules,
 		...strictOnly.rules,

package/dist/rules/index.d.ts

@@ -1,14 +1,21 @@
 import { _default } from "./no-constant-template-expression.js";
-import { _default as _default$1 } from "./no-empty-comment.js";
-import { _default as _default$2 } from "./no-empty-jsx-expression.js";
-import { _default as _default$3 } from "./no-extra-nested-boolean-cast.js";
-import { _default as _default$4 } from "./no-jsx-statement.js";
-import { _default as _default$5 } from "./no-ternary-return.js";
-import { _default as _default$6 } from "./unsafe-asserted-chain.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";
 
 //#region lib/rules/index.d.ts
 declare namespace index_d_exports {
-  export { _default as "no-constant-template-expression", _default$1 as "no-empty-comment", _default$2 as "no-empty-jsx-expression", _default$3 as "no-extra-nested-boolean-cast", _default$4 as "no-jsx-statement", _default$5 as "no-ternary-return", _default$6 as "unsafe-asserted-chain" };
+  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" };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -1,20 +1,34 @@
 import { __export } from "../_virtual/rolldown_runtime.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";
+import no_else_throw_default from "./no-else-throw.js";
 import no_empty_comment_default from "./no-empty-comment.js";
 import no_empty_jsx_expression_default from "./no-empty-jsx-expression.js";
 import no_extra_nested_boolean_cast_default from "./no-extra-nested-boolean-cast.js";
+import no_invalid_date_literal_default from "./no-invalid-date-literal.js";
 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_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({
 	"no-constant-template-expression": () => no_constant_template_expression_default,
+	"no-else-break": () => no_else_break_default,
+	"no-else-continue": () => no_else_continue_default,
+	"no-else-throw": () => no_else_throw_default,
 	"no-empty-comment": () => no_empty_comment_default,
 	"no-empty-jsx-expression": () => no_empty_jsx_expression_default,
 	"no-extra-nested-boolean-cast": () => no_extra_nested_boolean_cast_default,
+	"no-invalid-date-literal": () => no_invalid_date_literal_default,
 	"no-jsx-statement": () => no_jsx_statement_default,
+	"no-suspicious-jsx-semicolon": () => no_suspicious_jsx_semicolon_default,
 	"no-ternary-return": () => no_ternary_return_default,
+	"no-useless-iife": () => no_useless_iife_default,
+	"prefer-repeat": () => prefer_repeat_default,
 	"unsafe-asserted-chain": () => unsafe_asserted_chain_default
 });
 

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

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

package/dist/rules/no-else-break.js

@@ -0,0 +1,51 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-else-break.ts
+const { name } = path.parse(import.meta.filename);
+var no_else_break_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid unnecessary `else` block after a `break` statement",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noElseBreak: "Remove this unnecessary else" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			const { alternate } = node;
+			if (!alternate) return;
+			const lastConsequentStatement = getLastStatement(node.consequent);
+			if (!lastConsequentStatement) return;
+			if (lastConsequentStatement.type === AST_NODE_TYPES.BreakStatement) context.report({
+				node: alternate,
+				messageId: "noElseBreak",
+				*fix(fixer) {
+					const firstToken = context.sourceCode.getTokenBefore(alternate);
+					if (firstToken) yield fixer.remove(firstToken);
+					yield fixer.remove(alternate);
+					if (alternate.type === AST_NODE_TYPES.BlockStatement) {
+						const bodyText$1 = alternate.body.map((stmt) => context.sourceCode.getText(stmt)).join("\n");
+						yield fixer.insertTextAfter(node, bodyText$1);
+						return;
+					}
+					const bodyText = context.sourceCode.getText(alternate);
+					yield fixer.insertTextAfter(node, bodyText);
+				}
+			});
+		} };
+	}
+});
+function getLastStatement(stmt) {
+	if (stmt.type === AST_NODE_TYPES.BlockStatement) return stmt.body.at(-1);
+	return stmt;
+}
+
+//#endregion
+export { no_else_break_default as default };

package/dist/rules/no-else-continue.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/no-else-continue.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint1.RuleModule<"noElseContinue", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint1.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-else-continue.js

@@ -0,0 +1,51 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-else-continue.ts
+const { name } = path.parse(import.meta.filename);
+var no_else_continue_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid unnecessary `else` block after a `continue` statement",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noElseContinue: "Remove this unnecessary else" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			const { alternate } = node;
+			if (!alternate) return;
+			const lastConsequentStatement = getLastStatement(node.consequent);
+			if (!lastConsequentStatement) return;
+			if (lastConsequentStatement.type === AST_NODE_TYPES.ContinueStatement) context.report({
+				node: alternate,
+				messageId: "noElseContinue",
+				*fix(fixer) {
+					const firstToken = context.sourceCode.getTokenBefore(alternate);
+					if (firstToken) yield fixer.remove(firstToken);
+					yield fixer.remove(alternate);
+					if (alternate.type === AST_NODE_TYPES.BlockStatement) {
+						const bodyText$1 = alternate.body.map((stmt) => context.sourceCode.getText(stmt)).join("\n");
+						yield fixer.insertTextAfter(node, bodyText$1);
+						return;
+					}
+					const bodyText = context.sourceCode.getText(alternate);
+					yield fixer.insertTextAfter(node, bodyText);
+				}
+			});
+		} };
+	}
+});
+function getLastStatement(stmt) {
+	if (stmt.type === AST_NODE_TYPES.BlockStatement) return stmt.body.at(-1);
+	return stmt;
+}
+
+//#endregion
+export { no_else_continue_default as default };

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

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint3 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>;
+//#endregion
+export { _default };

package/dist/rules/no-else-throw.js

@@ -0,0 +1,51 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-else-throw.ts
+const { name } = path.parse(import.meta.filename);
+var no_else_throw_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid unnecessary `else` block after a `throw` statement",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noElseThrow: "Remove this unnecessary else" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			const { alternate } = node;
+			if (!alternate) return;
+			const lastConsequentStatement = getLastStatement(node.consequent);
+			if (!lastConsequentStatement) return;
+			if (lastConsequentStatement.type === AST_NODE_TYPES.ThrowStatement) context.report({
+				node: alternate,
+				messageId: "noElseThrow",
+				*fix(fixer) {
+					const firstToken = context.sourceCode.getTokenBefore(alternate);
+					if (firstToken) yield fixer.remove(firstToken);
+					yield fixer.remove(alternate);
+					if (alternate.type === AST_NODE_TYPES.BlockStatement) {
+						const bodyText$1 = alternate.body.map((stmt) => context.sourceCode.getText(stmt)).join("\n");
+						yield fixer.insertTextAfter(node, bodyText$1);
+						return;
+					}
+					const bodyText = context.sourceCode.getText(alternate);
+					yield fixer.insertTextAfter(node, bodyText);
+				}
+			});
+		} };
+	}
+});
+function getLastStatement(stmt) {
+	if (stmt.type === AST_NODE_TYPES.BlockStatement) return stmt.body.at(-1);
+	return stmt;
+}
+
+//#endregion
+export { no_else_throw_default as 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_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint5 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-empty-comment.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint0.RuleModule<"noEmptyComment", [{
+declare const _default: _typescript_eslint_utils_ts_eslint5.RuleModule<"noEmptyComment", [{
   allowStacked: boolean;
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint5.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_eslint1 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint7 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-empty-jsx-expression.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint1.RuleModule<"noEmptyJsxExpression", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint1.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint7.RuleModule<"noEmptyJsxExpression", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint7.RuleListener>;
 //#endregion
 export { _default };

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

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

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint11 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>;
+//#endregion
+export { _default };

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

@@ -0,0 +1,68 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-invalid-date-literal.ts
+const { name } = path.parse(import.meta.filename);
+var no_invalid_date_literal_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow invalid date literals",
+			recommended: true
+		},
+		schema: [],
+		messages: { noInvalidDateLiteral: "This results in an invalid date" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			NewExpression(node) {
+				if (node.arguments.length > 1) return;
+				const [arg] = node.arguments;
+				if (!arg) return;
+				if (arg.type === AST_NODE_TYPES.Identifier) {
+					if (["NaN", "Infinity"].includes(arg.name)) context.report({
+						node,
+						messageId: "noInvalidDateLiteral"
+					});
+					return;
+				}
+				if (arg.type !== AST_NODE_TYPES.Literal) return;
+				if (typeof arg.value === "string" || typeof arg.value === "number") {
+					if (isValidDateLiteral(arg.value)) return;
+					context.report({
+						node,
+						messageId: "noInvalidDateLiteral"
+					});
+				}
+			},
+			CallExpression(node) {
+				const { callee } = node;
+				if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
+				if (callee.object.type !== AST_NODE_TYPES.Identifier) return;
+				if (callee.property.type !== AST_NODE_TYPES.Identifier) return;
+				if (callee.object.name !== "Date") return;
+				if (callee.property.name !== "parse") return;
+				const [arg] = node.arguments;
+				if (!arg) return;
+				if (arg.type !== AST_NODE_TYPES.Literal) return;
+				if (typeof arg.value === "string") {
+					if (isValidDateLiteral(arg.value)) return;
+					context.report({
+						node,
+						messageId: "noInvalidDateLiteral"
+					});
+				}
+			}
+		};
+	}
+});
+function isValidDateLiteral(literal) {
+	const value = new Date(literal).valueOf();
+	return !Number.isNaN(value);
+}
+
+//#endregion
+export { no_invalid_date_literal_default as default };

package/dist/rules/no-jsx-statement.d.ts

@@ -1,7 +1,7 @@
 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_eslint13 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-jsx-statement.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint5.RuleModule<"noJsxExpressionStatement", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint5.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint13.RuleModule<"noJsxExpressionStatement", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint13.RuleListener>;
 //#endregion
 export { _default };

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

@@ -0,0 +1,8 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint15 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>;
+//#endregion
+export { _default };

package/dist/rules/no-suspicious-jsx-semicolon.js

@@ -0,0 +1,39 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+
+//#region lib/rules/no-suspicious-jsx-semicolon.ts
+const { name } = path.parse(import.meta.filename);
+var no_suspicious_jsx_semicolon_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid suspicious semicolons in JSX",
+			recommended: true
+		},
+		schema: [],
+		messages: {
+			noSuspiciousJsxSemicolon: "This semicolon looks suspiciously out of place. Did you add it on purpose?",
+			noSuspiciousJsxComma: "This comma looks suspiciously out of place. Did you add it on purpose?"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { JSXText(node) {
+			if (node.value.trim() === ";") {
+				context.report({
+					node,
+					messageId: "noSuspiciousJsxSemicolon"
+				});
+				return;
+			}
+			if (node.value.trimEnd() === ",") context.report({
+				node,
+				messageId: "noSuspiciousJsxComma"
+			});
+		} };
+	}
+});
+
+//#endregion
+export { no_suspicious_jsx_semicolon_default as default };

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

@@ -1,9 +1,9 @@
 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_eslint17 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-ternary-return.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint7.RuleModule<"noTernaryReturn", [{
+declare const _default: _typescript_eslint_utils_ts_eslint17.RuleModule<"noTernaryReturn", [{
   allowSingleLine: boolean;
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint7.RuleListener>;
+}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint17.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-useless-iife.d.ts

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint19 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/no-useless-iife.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint19.RuleModule<"noUselessIIFE" | "removeIIFE", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint19.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-useless-iife.js

@@ -0,0 +1,93 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-useless-iife.ts
+const { name } = path.parse(import.meta.filename);
+var no_useless_iife_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid useless IIFEs",
+			recommended: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			noUselessIIFE: "An IIFE is unnecessary here",
+			removeIIFE: "Remove this IIFE"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.FunctionExpression && callee.type !== AST_NODE_TYPES.ArrowFunctionExpression) return;
+			if (callee.body.type !== AST_NODE_TYPES.BlockStatement) {
+				context.report({
+					node,
+					messageId: "noUselessIIFE",
+					suggest: [{
+						messageId: "removeIIFE",
+						fix(fixer) {
+							return fixer.replaceText(node, context.sourceCode.getText(callee.body));
+						}
+					}]
+				});
+				return;
+			}
+			const { body } = callee.body;
+			const [lastStatement] = body;
+			if (!lastStatement) return;
+			if (body.length === 1 && lastStatement.type === AST_NODE_TYPES.ReturnStatement) {
+				context.report({
+					node,
+					messageId: "noUselessIIFE",
+					suggest: [{
+						messageId: "removeIIFE",
+						fix(fixer) {
+							const txt = lastStatement.argument ? context.sourceCode.getText(lastStatement.argument) : "undefined";
+							return fixer.replaceText(node, txt);
+						}
+					}]
+				});
+				return;
+			}
+			if (node.parent.type !== AST_NODE_TYPES.ExpressionStatement) return;
+			if (!body.some((stmt) => stmt.type === AST_NODE_TYPES.ExpressionStatement && stmt.expression.type === AST_NODE_TYPES.AwaitExpression)) {
+				context.report({
+					node,
+					messageId: "noUselessIIFE",
+					suggest: [{
+						messageId: "removeIIFE",
+						fix(fixer) {
+							const txt = context.sourceCode.getText(callee.body);
+							return fixer.replaceText(node, txt);
+						}
+					}]
+				});
+				return;
+			}
+			if (isStatementInAsyncFunction(node.parent)) context.report({
+				node,
+				messageId: "noUselessIIFE",
+				suggest: [{
+					messageId: "removeIIFE",
+					fix(fixer) {
+						const txt = context.sourceCode.getText(callee.body);
+						return fixer.replaceText(node, txt);
+					}
+				}]
+			});
+		} };
+	}
+});
+function isStatementInAsyncFunction(stmt) {
+	if (stmt.parent.type !== AST_NODE_TYPES.BlockStatement) return false;
+	if (stmt.parent.parent.type === AST_NODE_TYPES.FunctionDeclaration || stmt.parent.parent.type === AST_NODE_TYPES.ArrowFunctionExpression || stmt.parent.parent.type === AST_NODE_TYPES.FunctionExpression) return stmt.parent.parent.async;
+	return false;
+}
+
+//#endregion
+export { no_useless_iife_default as default };

package/dist/rules/prefer-repeat.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-repeat.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint21.RuleModule<"preferRepeat" | "replaceByRepeat", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint21.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/prefer-repeat.js

@@ -0,0 +1,108 @@
+import { createRule } from "../utils/createRule.js";
+import { None, Option, Some } from "../utils/option.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/prefer-repeat.ts
+const { name } = path.parse(import.meta.filename);
+var prefer_repeat_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce usage of `String.prototype.repeat`",
+			recommended: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			preferRepeat: "This could be simplified as `{{fixed}}`",
+			replaceByRepeat: "Replace by `{{fixed}}`"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { CallExpression(node) {
+			if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (node.callee.property.type !== AST_NODE_TYPES.Identifier) return;
+			if (!["reduce", "reduceRight"].includes(node.callee.property.name)) return;
+			const length = getConstructedArrayLength(node.callee.object);
+			if (!length.some) return;
+			const [arg] = node.arguments;
+			if (!arg) return;
+			const repeatedString = getRepeatedString(arg);
+			if (!repeatedString.some) return;
+			const n = context.sourceCode.getText(length.value);
+			const fixed = `${typeof repeatedString.value === "string" ? `'${repeatedString.value}'` : context.sourceCode.getText(repeatedString.value)}.repeat(${n})`;
+			context.report({
+				node,
+				messageId: "preferRepeat",
+				data: { fixed },
+				suggest: [{
+					messageId: "replaceByRepeat",
+					data: { fixed },
+					fix(fixer) {
+						return fixer.replaceText(node, fixed);
+					}
+				}]
+			});
+		} };
+	}
+});
+function getConstructedArrayLength(expr) {
+	if (expr.type !== AST_NODE_TYPES.CallExpression) return None;
+	const { callee } = expr;
+	if (callee.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (callee.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (callee.property.name === "from") {
+		if (callee.object.type !== AST_NODE_TYPES.Identifier) return None;
+		if (callee.object.name !== "Array") return None;
+		if (expr.arguments[0]?.type !== AST_NODE_TYPES.ObjectExpression) return None;
+		const { properties } = expr.arguments[0];
+		const length = properties.filter((prop) => prop.type === AST_NODE_TYPES.Property).find((prop) => prop.key.type === AST_NODE_TYPES.Identifier && prop.key.name === "length");
+		if (!length) return None;
+		return Some(length.value);
+	}
+	if (callee.property.name !== "fill") return None;
+	if (callee.object.type === AST_NODE_TYPES.CallExpression || callee.object.type === AST_NODE_TYPES.NewExpression) return Option.fromUndef(callee.object.arguments[0]);
+	return None;
+}
+function getRepeatedString(callback) {
+	if (callback.type !== AST_NODE_TYPES.FunctionExpression && callback.type !== AST_NODE_TYPES.ArrowFunctionExpression) return None;
+	const [acc] = callback.params;
+	if (!acc) return None;
+	if (acc.type !== AST_NODE_TYPES.Identifier) return None;
+	if (callback.body.type !== AST_NODE_TYPES.BlockStatement) return extractRepeatedString(callback.body, acc);
+	const returnStatement = callback.body.body.at(-1);
+	if (returnStatement?.type !== AST_NODE_TYPES.ReturnStatement) return None;
+	if (!returnStatement.argument) return None;
+	return extractRepeatedString(returnStatement.argument, acc);
+}
+function extractRepeatedString(expr, acc) {
+	if (expr.type === AST_NODE_TYPES.TemplateLiteral) return extractRepeatedStringFromTemplateLiteral(expr, acc);
+	if (expr.type === AST_NODE_TYPES.CallExpression) return extractRepeatedStringFromCallExpression(expr, acc);
+	return None;
+}
+function extractRepeatedStringFromTemplateLiteral(expr, acc) {
+	if (expr.expressions.length === 2) {
+		const str = expr.expressions.find((expression) => expression.type !== AST_NODE_TYPES.Identifier || expression.name !== acc.name);
+		return Option.fromUndef(str);
+	}
+	if (expr.expressions.length !== 1) return None;
+	if (expr.expressions[0]?.type !== AST_NODE_TYPES.Identifier) return None;
+	if (expr.expressions[0].name !== acc.name) return None;
+	if (expr.quasis.length !== 2) return None;
+	const quasi = expr.quasis.map((q) => q.value.cooked).find(Boolean);
+	return Option.fromUndef(quasi);
+}
+function extractRepeatedStringFromCallExpression(expr, acc) {
+	if (expr.callee.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (expr.callee.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (expr.callee.property.name !== "concat") return None;
+	if (expr.callee.object.type !== AST_NODE_TYPES.Identifier) return None;
+	if (expr.callee.object.name !== acc.name) return None;
+	return Option.fromUndef(expr.arguments[0]);
+}
+
+//#endregion
+export { prefer_repeat_default as default };

package/dist/utils/option.js

@@ -0,0 +1,18 @@
+//#region lib/utils/option.ts
+const Option = { fromUndef: (value) => {
+	if (value === void 0) return None;
+	return Some(value);
+} };
+const None = {
+	value: null,
+	some: false
+};
+function Some(value) {
+	return {
+		value,
+		some: true
+	};
+}
+
+//#endregion
+export { None, Option, Some };

package/package.json

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

package/docs/rules/no-constant-template-expression.md

@@ -1,83 +0,0 @@
-# Disallow constant string expressions in template literals (`wyrm/no-constant-template-expression`)
-
-💼 This rule is enabled in the ☑️ `strictTypeChecked` config.
-
-💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
-
-💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
-
-## Description
-
-It is sometimes clearer to inline interpolated expressions when their values are constant:
-
-### Example
-
-```ts
-const foo = 'foobar';
-const str = `${foo}_baz`;
-// This would be clearer as:
-const str = 'foobar_baz';
-```
-
-By default, this rule allows constant values when they take up at least 10 characters.
-This can be configured with the `minAllowedLength` option.
-
-## Cases
-
-### Incorrect ❌
-
-Template expression with a constant string value:
-
-```tsx
-const foo = 'foobar';
-const str = `${foo}_baz`;
-```
-
-Template expression with a constant number value:
-
-```tsx
-const n = 42;
-const str = `${n}_baz`;
-```
-
-Template expression with a constant boolean value:
-
-```tsx
-const bool = true;
-const str = `${bool}_baz`;
-```
-
-With a 14 character string (`minAllowedLength: 15`):
-
-```tsx
-const foo = '12345678901234';
-const str = `${foo}_baz`;
-```
-
-### Correct ✅
-
-Template expression typed as string:
-
-```tsx
-declare const foo: string;
-const str = `${foo}_baz`;
-```
-
-Template expression with a 10 character string value (as long as the default `minAllowedLength` value):
-
-```tsx
-const n = 'aaaaaaaaaa';
-const str = `${n}_baz`;
-```
-
-<!-- end auto-generated rule header -->
-
-## Options
-
-<!-- begin auto-generated rule options list -->
-
-| Name               | Description                                                         | Type   |
-| :----------------- | :------------------------------------------------------------------ | :----- |
-| `minAllowedLength` | Minimum string length allowed for constant expressions. Default: 10 | Number |
-
-<!-- end auto-generated rule options list -->

package/docs/rules/no-empty-comment.md

@@ -1,70 +0,0 @@
-# Forbid empty comments (`wyrm/no-empty-comment`)
-
-💼 This rule is enabled in the following configs: 🟪 `strict`, ☑️ `strictTypeChecked`.
-
-## Cases
-
-### Incorrect ❌
-
-Empty inline comment:
-
-```tsx
-//
-```
-
-Empty block comment:
-
-```tsx
-/* */
-```
-
-Empty JSDoc comment:
-
-```tsx
-/** */
-```
-
-Stacked empty comments (with `allowStacked: false`):
-
-```tsx
-//
-// Ok
-//
-```
-
-Several stacked empty comments (with `allowStacked: true`):
-
-```tsx
-//
-// Ok
-//
-//
-```
-
-### Correct ✅
-
-Not an empty comment:
-
-```tsx
-// Ok
-```
-
-Stacked empty comments (with `allowStacked: true`):
-
-```tsx
-//
-// Ok
-//
-```
-
-<!-- end auto-generated rule header -->
-
-## Options
-
-<!-- begin auto-generated rule options list -->
-
-| Name           | Description                                                                          | Type    |
-| :------------- | :----------------------------------------------------------------------------------- | :------ |
-| `allowStacked` | Whether to allow empty comments stacked next to non-empty comments. Default: `false` | Boolean |
-
-<!-- end auto-generated rule options list -->

package/docs/rules/no-empty-jsx-expression.md

@@ -1,77 +0,0 @@
-# Forbid empty JSX expression containers (`wyrm/no-empty-jsx-expression`)
-
-💼 This rule is enabled in the following configs: 🟩 `recommended`, ✅ `recommendedTypeChecked`, 🟪 `strict`, ☑️ `strictTypeChecked`.
-
-## Cases
-
-### Incorrect ❌
-
-Empty JSX expression container:
-
-```tsx
-function Foo() {
-  return (
-    <div>
-      {}
-      Ok
-    </div>
-  );
-}
-```
-
-JSX expression container with only a literal `null`:
-
-```tsx
-function Foo() {
-  return <div>{null}</div>;
-}
-```
-
-JSX expression container with only a literal `undefined`:
-
-```tsx
-function Foo() {
-  return <div>{undefined}</div>;
-}
-```
-
-JSX expression container with only a literal `false`:
-
-```tsx
-function Foo() {
-  return <div>{false}</div>;
-}
-```
-
-JSX expression container with only a literal empty string:
-
-```tsx
-function Foo() {
-  return <div>{''}</div>;
-}
-```
-
-### Correct ✅
-
-JSX expression container is not empty:
-
-```tsx
-function Foo({ children }: PropsWithChildren) {
-  return <div>{children}</div>;
-}
-```
-
-JSX expression container with a comment:
-
-```tsx
-function Foo() {
-  return (
-    <div>
-      {/* A comment */}
-      Ok
-    </div>
-  );
-}
-```
-
-<!-- end auto-generated rule header -->

package/docs/rules/no-extra-nested-boolean-cast.md

@@ -1,112 +0,0 @@
-# Forbid extra boolean casts in conditions and predicates (`wyrm/no-extra-nested-boolean-cast`)
-
-💼 This rule is enabled in the following configs: 🟪 `strict`, ☑️ `strictTypeChecked`.
-
-## Description
-
-When an expression is inside a conditional test, it is implicitly coerced to a boolean.
-Casting this expression to a boolean is therefore redundant.
-
-This rule supplements the builtin [`no-extra-boolean-cast`](https://eslint.org/docs/latest/rules/no-extra-boolean-cast) ESLint rule.
-The `wyrm/no-extra-nested-boolean-cast` should have the same behavior as the builtin rule with the `enforceForInnerExpressions` option enabled, but it also supports some TypeScript constructs.
-
-Contrary to the builtin rule, it also enforces this for callback returns of some array methods like `Array.prototype.find` or `Array.prototype.filter`.
-
-### Example
-
-```ts
-declare const foo: string;
-// `foo` doesn't need to be coerced to a boolean, because it is inside a ternary condition:
-const bar = !!foo ? 'ok' : 'ko';
-```
-
-This rules conflicts with the [`@typescript-eslint/strict-boolean-expressions`](https://typescript-eslint.io/rules/strict-boolean-expressions/) rule.
-
-## Cases
-
-### Incorrect ❌
-
-Redundant double negation:
-
-```tsx
-declare const foo: string;
-
-if (!!bar) {
-  console.log('foo!');
-}
-```
-
-Redundant double negation inside of another boolean cast:
-
-```tsx
-const x = Boolean(!!foo);
-```
-
-Redundant double negation in return of array method predicate:
-
-```tsx
-declare const arr: string[];
-const isOkay = arr.filter((elt) => !!elt);
-```
-
-Redundant double negations in logical sub-expressions:
-
-```tsx
-declare const foo: string;
-declare const bar: string;
-declare const baz: string;
-
-if (!!bar && (!!foo || !!baz)) {
-  console.log('foo!');
-}
-```
-
-Redundant Boolean calls:
-
-```tsx
-declare const foo: string;
-declare const bar: string;
-declare const baz: string;
-
-if (Boolean(bar) && (Boolean(foo) || Boolean(baz))) {
-  console.log('foo!');
-}
-```
-
-Redundant double negations nested in type assertions:
-
-```tsx
-declare const foo: string;
-declare const bar: string;
-declare const baz: string;
-
-if ((!!bar)! && ((!!foo satisfies boolean) || (!!baz as any))) {
-  console.log('foo!');
-}
-```
-
-### Correct ✅
-
-No extra boolean cast:
-
-```tsx
-declare const foo: string;
-declare const bar: string;
-declare const baz: string;
-
-if (bar && (foo || baz)) {
-  console.log('foo!');
-}
-```
-
-Short-circuiting expression:
-
-```tsx
-declare const foo: string;
-declare const bar: string;
-declare const baz: string;
-
-const val = !!bar && (!!foo || !!baz);
-```
-
-<!-- end auto-generated rule header -->

package/docs/rules/no-jsx-statement.md

@@ -1,36 +0,0 @@
-# Forbid JSX expression statements (`wyrm/no-jsx-statement`)
-
-💼 This rule is enabled in the following configs: 🟩 `recommended`, ✅ `recommendedTypeChecked`, 🟪 `strict`, ☑️ `strictTypeChecked`.
-
-## Cases
-
-### Incorrect ❌
-
-JSX fragment in expression statement:
-
-```tsx
-export function MyComponent() {
-  <></>;
-}
-```
-
-### Correct ✅
-
-JSX element in return statement:
-
-```tsx
-export function MyComponent() {
-  return <div />;
-}
-```
-
-JSX element in variable initialization:
-
-```tsx
-export function MyComponent() {
-  const jsx = <div />;
-  return jsx;
-}
-```
-
-<!-- end auto-generated rule header -->

package/docs/rules/no-ternary-return.md

@@ -1,46 +0,0 @@
-# Disallow ternary conditions in return statements (`wyrm/no-ternary-return`)
-
-💼 This rule is enabled in the following configs: 🟪 `strict`, ☑️ `strictTypeChecked`.
-
-🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
-
-## Cases
-
-### Incorrect ❌
-
-Ternary return:
-
-```tsx
-function foo(cond: boolean) {
-  return cond ? 42 : 105;
-}
-```
-
-### Correct ✅
-
-No ternary return:
-
-```tsx
-function foo(cond: boolean) {
-  if (cond) return 42;
-  return 105;
-}
-```
-
-Inline arrow function:
-
-```tsx
-const foo = (cond: boolean) => (cond ? 42 : 105);
-```
-
-<!-- end auto-generated rule header -->
-
-## Options
-
-<!-- begin auto-generated rule options list -->
-
-| Name              | Description                                                       | Type    |
-| :---------------- | :---------------------------------------------------------------- | :------ |
-| `allowSingleLine` | Whether to allow single line ternary conditions. Default: `false` | Boolean |
-
-<!-- end auto-generated rule options list -->

package/docs/rules/unsafe-asserted-chain.md

@@ -1,68 +0,0 @@
-# Disallow unsafe type assertions on optional chained expressions (`wyrm/unsafe-asserted-chain`)
-
-💼 This rule is enabled in the ☑️ `strictTypeChecked` config.
-
-💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
-
-## Description
-
-This rule supplements the [`@typescript-eslint/no-non-null-asserted-optional-chain`](https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain/) ESLint rule.
-
-It checks for type assertions on optional chain expressions (`?.`) where the asserted type doesn't include `undefined`.
-
-Optional chaining can return `undefined` by default, so this is likely a mistake.
-
-This rule only makes sense if you have `strictNullChecks` enabled in your `tsconfig.json` (this is the default for `strict: true`).
-
-### Example
-
-```ts
-foo?.bar as string;
-// This should be:
-foo?.bar as string | undefined;
-// Or, if the optional chaining isn't actually necessary:
-foo.bar as string;
-```
-
-## Cases
-
-### Incorrect ❌
-
-Optional chain asserted as not undefined:
-
-```tsx
-declare const foo: { bar: string | number } | null;
-const str = (foo?.bar as string).toUpperCase();
-```
-
-Optional chain call expression asserted as not undefined:
-
-```tsx
-declare const foo: { bar: () => string | number } | null;
-const str = (foo?.bar() as string | number)?.toString();
-```
-
-### Correct ✅
-
-Optional chain asserted as nullable:
-
-```tsx
-declare const foo: { bar: string | number } | null;
-const str = (foo?.bar as string | undefined)?.toUpperCase();
-```
-
-Optional chain asserted as any:
-
-```tsx
-declare const foo: { bar: string | number } | null;
-const str = (foo?.bar as any)?.toUpperCase();
-```
-
-Optional chain asserted as unknown:
-
-```tsx
-declare const foo: { bar: string | number } | null;
-const str = (foo?.bar as unknown)?.toUpperCase();
-```
-
-<!-- end auto-generated rule header -->