eslint-plugin-wyrm 0.0.4 → 0.0.5

package/CHANGELOG.md

@@ -1,27 +1,14 @@
 # Changelog
 
-## [0.0.4](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.3...eslint-plugin-wyrm-v0.0.4) (2025-11-01)
-
-
-### Bug Fixes
-
-* improve no-extra-nested-boolean-cast ([333d0f3](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/333d0f3bcc3aa73a329bb9ff60189490f96813cd))
-
-## [0.0.3](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.2...eslint-plugin-wyrm-v0.0.3) (2025-10-26)
+## [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)
 
 
 ### Bug Fixes
 
-* ignore CHANGELOG.md formatting ([f6a923c](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/f6a923c348be8c2976635ae64a45c75932faba60))
-
-## 0.0.2 (2025-10-26)
+* add no-ternary-return ([4e029be](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/4e029be3f157601bbbb5b9cb854a526ad88b2c1e))
 
+## [0.0.4](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.3...eslint-plugin-wyrm-v0.0.4) (2025-11-01)
 
 ### Bug Fixes
 
-* rule doc url ([1ae7be1](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/1ae7be12ffa2811f22909b36b415061ddf890a2b))
-
-
-### Miscellaneous Chores
-
-* Merge npm-publish.yml with release.yml ([fba85e8](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/fba85e8ff67e5274aedb63db60756a5a41ab010f))
+- improve no-extra-nested-boolean-cast ([333d0f3](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/333d0f3bcc3aa73a329bb9ff60189490f96813cd))

package/README.md

@@ -4,16 +4,35 @@
 [![GitHub release](https://img.shields.io/github/v/release/mchevestrier/eslint-plugin-wyrm?color=7f52af&labelColor=26272b)](https://github.com/mchevestrier/eslint-plugin-wyrm/releases/latest)
 [![GitHub License](https://img.shields.io/badge/license-MIT-232428.svg?color=7f52af&labelColor=26272b)](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/main/LICENSE.md)
 
+## Installation
+
+```shell
+npm install --save-dev eslint eslint-plugin-wyrm
+```
+
+## Usage
+
+```ts
+import { defineConfig } from 'eslint/config';
+import wyrm from 'eslint-plugin-wyrm';
+
+export default defineConfig([
+  // ...
+
+  wyrm.configs.recommended,
+]);
+```
+
 ## Configs
 
 <!-- begin auto-generated configs list -->
 
-|     | Name                          |
-| :-- | :---------------------------- |
-| ✅  | `wyrm/recommended`            |
-| ☑️  | `wyrm/recommendedTypeChecked` |
-| 🟢  | `wyrm/strict`                 |
-| 🟣  | `wyrm/strictTypeChecked`      |
+|     | Name                     |
+| :-- | :----------------------- |
+| 🟩  | `recommended`            |
+| ✅  | `recommendedTypeChecked` |
+| 🟪  | `strict`                 |
+| ☑️  | `strictTypeChecked`      |
 
 <!-- end auto-generated configs list -->
 
@@ -22,16 +41,22 @@
 <!-- begin auto-generated rules list -->
 
 💼 Configurations enabled in.\
-✅ Set in the `wyrm/recommended` configuration.\
-☑️ Set in the `wyrm/recommendedTypeChecked` configuration.\
-🟢 Set in the `wyrm/strict` configuration.\
-🟣 Set in the `wyrm/strictTypeChecked` configuration.\
+🟩 Set in the `recommended` configuration.\
+✅ Set in the `recommendedTypeChecked` configuration.\
+🟪 Set in the `strict` configuration.\
+☑️ Set in the `strictTypeChecked` configuration.\
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
+💡 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-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-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                                | ✅ ☑️ 🟢 🟣 |     |
-| [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                                                     | 💼          | 🔧  | 💡  | 💭  |
+| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------- | :---------- | :-- | :-- | :-- |
+| [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-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-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-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                | 🟪 ☑️       | 🔧  |     |     |
+| [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.d.ts

@@ -1,10 +1,10 @@
-import { Linter } from "eslint";
+import { FlatConfig } from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/configs/index.d.ts
 declare namespace index_d_exports {
   export { all, recommended, recommendedTypeChecked, recommendedTypeCheckedOnly, strict, strictOnly, strictTypeChecked, strictTypeCheckedOnly };
 }
-type Config = Linter.Config;
+type Config = FlatConfig.Config;
 declare const all: Config;
 declare const recommended: Config;
 declare const strictOnly: Config;

package/dist/configs/index.js

@@ -1,7 +1,6 @@
 import { __export } from "../_virtual/rolldown_runtime.js";
 import { rules_exports } from "../rules/index.js";
 import { plugin } from "../plugin.js";
-import { Linter } from "eslint";
 
 //#region lib/configs/index.ts
 var configs_exports = /* @__PURE__ */ __export({
@@ -17,12 +16,12 @@ var configs_exports = /* @__PURE__ */ __export({
 const baseConfig = { plugins: { get wyrm() {
 	return plugin;
 } } };
-function createConfigWithRules(initialRules, name, pred) {
-	const filteredRules = Object.entries(initialRules).filter(([, rule]) => pred(rule)).map(([name$1]) => [`wyrm/${name$1}`, "error"]);
+function createConfigWithRules(initialRules, configName, pred) {
+	const filteredRules = Object.entries(initialRules).filter(([, rule]) => pred(rule)).map(([ruleName]) => [`wyrm/${ruleName}`, "error"]);
 	const rules = Object.fromEntries(filteredRules);
 	return {
 		...baseConfig,
-		name: `wyrm/${name}`,
+		name: `wyrm/${configName}`,
 		rules
 	};
 }

package/dist/index.d.ts

@@ -2,9 +2,13 @@ import { index_d_exports } from "./configs/index.js";
 import { index_d_exports as index_d_exports$1 } from "./rules/index.js";
 
 //#region lib/index.d.ts
+interface CompatibleConfig {
+  name?: string;
+  rules?: object;
+}
 declare const plugin: {
   rules: typeof index_d_exports$1;
-  configs: typeof index_d_exports;
+  configs: Record<keyof typeof index_d_exports, CompatibleConfig>;
 };
 //#endregion
 export { plugin as default };

package/dist/plugin.js

@@ -1,5 +1,4 @@
 import { rules_exports } from "./rules/index.js";
-import { configs_exports } from "./configs/index.js";
 import { createRequire } from "node:module";
 
 //#region lib/plugin.ts
@@ -9,7 +8,6 @@ const plugin = {
 		name,
 		version
 	},
-	configs: configs_exports,
 	rules: rules_exports
 };
 

package/dist/rules/index.d.ts

@@ -1,10 +1,14 @@
-import { _default } from "./no-extra-nested-boolean-cast.js";
-import { _default as _default$1 } from "./no-jsx-statement.js";
-import { _default as _default$2 } from "./unsafe-asserted-chain.js";
+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";
 
 //#region lib/rules/index.d.ts
 declare namespace index_d_exports {
-  export { _default as "no-extra-nested-boolean-cast", _default$1 as "no-jsx-statement", _default$2 as "unsafe-asserted-chain" };
+  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" };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -1,12 +1,20 @@
 import { __export } from "../_virtual/rolldown_runtime.js";
+import no_constant_template_expression_default from "./no-constant-template-expression.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_jsx_statement_default from "./no-jsx-statement.js";
+import no_ternary_return_default from "./no-ternary-return.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-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-jsx-statement": () => no_jsx_statement_default,
+	"no-ternary-return": () => no_ternary_return_default,
 	"unsafe-asserted-chain": () => unsafe_asserted_chain_default
 });
 

package/dist/rules/no-constant-template-expression.d.ts

@@ -0,0 +1,10 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-constant-template-expression.d.ts
+
+declare const _default: ESLintUtils.RuleModule<"noConstantTemplateExpression" | "replaceByString", [{
+  minAllowedLength: number;
+}], WyrmPluginDocs, ESLintUtils.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-constant-template-expression.js

@@ -0,0 +1,82 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { ASTUtils, AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-constant-template-expression.ts
+const { name } = path.parse(import.meta.filename);
+const DEFAULT_MIN_ALLOWED_LENGTH = 10;
+var no_constant_template_expression_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow constant string expressions in template literals",
+			requiresTypeChecking: true,
+			strict: true
+		},
+		hasSuggestions: true,
+		schema: [{
+			type: "object",
+			properties: { minAllowedLength: {
+				type: "number",
+				description: `Minimum string length allowed for constant expressions. Default: ${DEFAULT_MIN_ALLOWED_LENGTH}`
+			} }
+		}],
+		messages: {
+			noConstantTemplateExpression: "Replace this constant template expression by its value as a string ('{{value}}')",
+			replaceByString: "Replace by '{{value}}'"
+		}
+	},
+	defaultOptions: [{ minAllowedLength: DEFAULT_MIN_ALLOWED_LENGTH }],
+	create(context, [options]) {
+		return { TemplateLiteral(node) {
+			const services = ESLintUtils.getParserServices(context);
+			const checker = services.program.getTypeChecker();
+			const { expressions, quasis } = node;
+			if (quasis.some((quasi) => quasi.value.cooked.includes(" "))) return;
+			const scope = context.sourceCode.getScope(node);
+			for (const expr of expressions) {
+				if (expr.type === AST_NODE_TYPES.Identifier) {
+					const variable = ASTUtils.findVariable(scope, expr);
+					if (variable) {
+						const { references, defs } = variable;
+						if (references.length > 2) continue;
+						const def = defs.at(-1);
+						if (def?.parent?.type === AST_NODE_TYPES.VariableDeclaration && (def.parent.parent.type === AST_NODE_TYPES.ExportNamedDeclaration || def.parent.parent.type === AST_NODE_TYPES.ExportDefaultDeclaration)) continue;
+					}
+				}
+				const value = getLiteralValue(services.getTypeAtLocation(expr), checker);
+				if (value === null) continue;
+				if (value.length >= options.minAllowedLength) return;
+				context.report({
+					node: expr,
+					messageId: "noConstantTemplateExpression",
+					data: { value },
+					suggest: [{
+						messageId: "replaceByString",
+						data: { value },
+						fix(fixer) {
+							const [identStart, identEnd] = expr.range;
+							const previousQuasi = quasis.toReversed().find((quasi) => quasi.range[1] <= identStart);
+							const nextQuasi = quasis.find((quasi) => quasi.range[0] >= identEnd);
+							const start = previousQuasi?.range[1] ?? node.range[0];
+							const end = nextQuasi?.range[0] ?? node.range[1];
+							const range = [start - 2, end + 1];
+							return fixer.replaceTextRange(range, value);
+						}
+					}]
+				});
+			}
+		} };
+	}
+});
+function getLiteralValue(type, checker) {
+	if (type.isStringLiteral()) return type.value;
+	if (type.isNumberLiteral()) return type.value.toString();
+	if (type === checker.getTrueType()) return "true";
+	if (type === checker.getFalseType()) return "false";
+	return null;
+}
+
+//#endregion
+export { no_constant_template_expression_default as default };

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

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

package/dist/rules/no-empty-comment.js

@@ -0,0 +1,57 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-empty-comment.ts
+const { name } = path.parse(import.meta.filename);
+const DEFAULT_ALLOW_STACKED = false;
+var no_empty_comment_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid empty comments",
+			strict: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { allowStacked: {
+				type: "boolean",
+				description: `Whether to allow empty comments stacked next to non-empty comments. Default: \`${DEFAULT_ALLOW_STACKED}\``
+			} }
+		}],
+		messages: { noEmptyComment: "Remove this empty comment" }
+	},
+	defaultOptions: [{ allowStacked: DEFAULT_ALLOW_STACKED }],
+	create(context, [options]) {
+		if (typeof context.sourceCode.getAllComments === "undefined") return {};
+		const comments = context.sourceCode.getAllComments();
+		for (const comment of comments) {
+			if (!isEmptyComment(comment)) continue;
+			if (options.allowStacked && isStackedComment(comment, comments)) continue;
+			context.report({
+				node: comment,
+				messageId: "noEmptyComment"
+			});
+		}
+		return {};
+	}
+});
+function isEmptyComment(comment) {
+	return !comment.value.replace(/^\*/u, "").replaceAll("*\n", "").trim();
+}
+function isStackedComment(comment, comments) {
+	if (comment.type !== AST_TOKEN_TYPES.Line) return false;
+	return comments.some((otherComment) => {
+		if (otherComment === comment) return false;
+		if (otherComment.type !== AST_TOKEN_TYPES.Line) return false;
+		if (isEmptyComment(otherComment)) return false;
+		if (otherComment.loc.start.line === comment.loc.start.line - 1) return true;
+		if (otherComment.loc.start.line === comment.loc.start.line + 1) return true;
+		return false;
+	});
+}
+
+//#endregion
+export { no_empty_comment_default as default };

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

package/dist/rules/no-empty-jsx-expression.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-empty-jsx-expression.ts
+const { name } = path.parse(import.meta.filename);
+var no_empty_jsx_expression_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid empty JSX expression containers",
+			recommended: true
+		},
+		schema: [],
+		messages: { noEmptyJsxExpression: "Remove this empty JSX expression container" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			JSXEmptyExpression(node) {
+				if (context.sourceCode.getCommentsInside(node).length) return;
+				context.report({
+					node,
+					messageId: "noEmptyJsxExpression"
+				});
+			},
+			JSXExpressionContainer(node) {
+				if (node.expression.type === AST_NODE_TYPES.JSXEmptyExpression) return;
+				switch (node.expression.type) {
+					case AST_NODE_TYPES.Literal:
+						if (node.expression.value === null) break;
+						if (node.expression.value === false) break;
+						if (node.expression.value === "") break;
+						return;
+					case AST_NODE_TYPES.Identifier:
+						if (node.expression.name === "undefined") break;
+						return;
+					default: return;
+				}
+				context.report({
+					node,
+					messageId: "noEmptyJsxExpression"
+				});
+			}
+		};
+	}
+});
+
+//#endregion
+export { no_empty_jsx_expression_default as 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_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint3 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-extra-nested-boolean-cast.d.ts
 
-declare const _default: _typescript_eslint_utils_ts_eslint0.RuleModule<"noExtraBooleanCastInCondition" | "noExtraBooleanCastInPredicate" | "noExtraBooleanCastInsideAnother", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint3.RuleModule<"noExtraBooleanCastInCondition" | "noExtraBooleanCastInPredicate" | "noExtraBooleanCastInsideAnother", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint3.RuleListener>;
 //#endregion
 export { _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_eslint1 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint5 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-jsx-statement.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint1.RuleModule<"noJsxExpressionStatement", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint1.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint5.RuleModule<"noJsxExpressionStatement", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint5.RuleListener>;
 //#endregion
 export { _default };

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

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

package/dist/rules/no-ternary-return.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-ternary-return.ts
+const { name } = path.parse(import.meta.filename);
+const DEFAULT_ALLOW_SINGLE_LINE = false;
+var no_ternary_return_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow ternary conditions in return statements",
+			strict: true
+		},
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { allowSingleLine: {
+				type: "boolean",
+				description: `Whether to allow single line ternary conditions. Default: \`${DEFAULT_ALLOW_SINGLE_LINE}\``
+			} }
+		}],
+		messages: { noTernaryReturn: "Replace this ternary condition by multiple return statements" }
+	},
+	defaultOptions: [{ allowSingleLine: DEFAULT_ALLOW_SINGLE_LINE }],
+	create(context, [options]) {
+		return { ReturnStatement(node) {
+			const { argument } = node;
+			if (!argument) return;
+			if (argument.type !== AST_NODE_TYPES.ConditionalExpression) return;
+			if (options.allowSingleLine && argument.loc.start.line === argument.loc.end.line) return;
+			const { test, consequent, alternate } = argument;
+			context.report({
+				node,
+				messageId: "noTernaryReturn",
+				*fix(fixer) {
+					const condText = context.sourceCode.getText(test);
+					const thenText = context.sourceCode.getText(consequent);
+					const elseText = context.sourceCode.getText(alternate);
+					const indent = " ".repeat(node.loc.start.column);
+					yield fixer.replaceText(node, `if (${condText}) return ${thenText};`);
+					yield fixer.insertTextAfter(node, `\n${indent}return ${elseText};`);
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+export { no_ternary_return_default as default };

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

@@ -0,0 +1,83 @@
+# 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

@@ -0,0 +1,70 @@
+# 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

@@ -0,0 +1,77 @@
+# 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,6 +1,6 @@
 # Forbid extra boolean casts in conditions and predicates (`wyrm/no-extra-nested-boolean-cast`)
 
-💼 This rule is enabled in the following configs: 🟢 `wyrm/strict`, 🟣 `wyrm/strictTypeChecked`.
+💼 This rule is enabled in the following configs: 🟪 `strict`, ☑️ `strictTypeChecked`.
 
 ## Description
 
@@ -20,13 +20,15 @@ declare const foo: string;
 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 ❌
 
-```tsx
-// Redundant double negation
+Redundant double negation:
 
+```tsx
 declare const foo: string;
 
 if (!!bar) {
@@ -34,22 +36,22 @@ if (!!bar) {
 }
 ```
 
-```tsx
-// Redundant double negation inside of another boolean cast
+Redundant double negation inside of another boolean cast:
 
+```tsx
 const x = Boolean(!!foo);
 ```
 
-```tsx
-// Redundant double negation in return of array method predicate
+Redundant double negation in return of array method predicate:
 
+```tsx
 declare const arr: string[];
 const isOkay = arr.filter((elt) => !!elt);
 ```
 
-```tsx
-// Redundant double negations in logical sub-expressions
+Redundant double negations in logical sub-expressions:
 
+```tsx
 declare const foo: string;
 declare const bar: string;
 declare const baz: string;
@@ -59,9 +61,9 @@ if (!!bar && (!!foo || !!baz)) {
 }
 ```
 
-```tsx
-// Redundant Boolean calls
+Redundant Boolean calls:
 
+```tsx
 declare const foo: string;
 declare const bar: string;
 declare const baz: string;
@@ -71,9 +73,9 @@ if (Boolean(bar) && (Boolean(foo) || Boolean(baz))) {
 }
 ```
 
-```tsx
-// Redundant double negations nested in type assertions
+Redundant double negations nested in type assertions:
 
+```tsx
 declare const foo: string;
 declare const bar: string;
 declare const baz: string;
@@ -85,9 +87,9 @@ if ((!!bar)! && ((!!foo satisfies boolean) || (!!baz as any))) {
 
 ### Correct ✅
 
-```tsx
-// No extra boolean cast
+No extra boolean cast:
 
+```tsx
 declare const foo: string;
 declare const bar: string;
 declare const baz: string;
@@ -97,9 +99,9 @@ if (bar && (foo || baz)) {
 }
 ```
 
-```tsx
-// Short-circuiting expression
+Short-circuiting expression:
 
+```tsx
 declare const foo: string;
 declare const bar: string;
 declare const baz: string;

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

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

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

@@ -0,0 +1,46 @@
+# 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,6 +1,6 @@
 # Disallow unsafe type assertions on optional chained expressions (`wyrm/unsafe-asserted-chain`)
 
-💼 This rule is enabled in the 🟣 `wyrm/strictTypeChecked` config.
+💼 This rule is enabled in the ☑️ `strictTypeChecked` config.
 
 💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
@@ -28,39 +28,39 @@ foo.bar as string;
 
 ### Incorrect ❌
 
-```tsx
-// Optional chain asserted as not undefined
+Optional chain asserted as not undefined:
 
+```tsx
 declare const foo: { bar: string | number } | null;
 const str = (foo?.bar as string).toUpperCase();
 ```
 
-```tsx
-// Optional chain call expression asserted as not undefined
+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 ✅
 
-```tsx
-// Optional chain asserted as nullable
+Optional chain asserted as nullable:
 
+```tsx
 declare const foo: { bar: string | number } | null;
 const str = (foo?.bar as string | undefined)?.toUpperCase();
 ```
 
-```tsx
-// Optional chain asserted as any
+Optional chain asserted as any:
 
+```tsx
 declare const foo: { bar: string | number } | null;
 const str = (foo?.bar as any)?.toUpperCase();
 ```
 
-```tsx
-// Optional chain asserted as unknown
+Optional chain asserted as unknown:
 
+```tsx
 declare const foo: { bar: string | number } | null;
 const str = (foo?.bar as unknown)?.toUpperCase();
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-wyrm",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Some custom ESLint rules",
   "keywords": [
     "eslint",
@@ -36,6 +36,7 @@
     "eslint": ">=9.38.0",
     "eslint-doc-generator": "^2.3.0",
     "jest-diff": "^30.2.0",
+    "jiti": "^2.6.1",
     "markdownlint-cli2": "^0.18.1",
     "prettier": "^3.6.2",
     "tsdown": "^0.15.9",
@@ -52,6 +53,7 @@
     "fix:eslint-docs": "eslint-doc-generator",
     "fix:format": "prettier --write .",
     "fix:js": "eslint . --fix",
+    "preinit:eslint-docs": "pnpm run build",
     "init:eslint-docs": "eslint-doc-generator --init-rule-docs",
     "lint:docs": "markdownlint-cli2 \"**/*.md\" \"#node_modules\" \"#CHANGELOG.md\"",
     "lint:eslint-docs": "eslint-doc-generator --check",