eslint-plugin-wyrm 0.0.10 → 0.0.13

package/dist/rules/index.mjs

@@ -1,15 +1,42 @@
-import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import array_from_array_default from "./array-from-array.mjs";
+import as_unknown_as_default from "./as-unknown-as.mjs";
+import await_promise_resolve_default from "./await-promise-resolve.mjs";
+import boolean_coalescing_default from "./boolean-coalescing.mjs";
+import comment_duplicate_leading_space_default from "./comment-duplicate-leading-space.mjs";
+import conditional_boolean_default from "./conditional-boolean.mjs";
+import constant_boolean_cast_default from "./constant-boolean-cast.mjs";
 import de_morgan_default from "./de-morgan.mjs";
+import discarded_expression_statement_default from "./discarded-expression-statement.mjs";
 import distribute_boolean_casts_default from "./distribute-boolean-casts.mjs";
 import duplicate_destructuring_default from "./duplicate-destructuring.mjs";
+import duplicate_object_spread_default from "./duplicate-object-spread.mjs";
+import e_default from "./e.mjs";
+import empty_for_default from "./empty-for.mjs";
+import enum_member_default from "./enum-member.mjs";
+import eqeq_null_default from "./eqeq-null.mjs";
+import exact_string_regex_default from "./exact-string-regex.mjs";
+import export_using_default from "./export-using.mjs";
+import generic_constructor_with_hook_default from "./generic-constructor-with-hook.mjs";
 import idiomatic_cast_default from "./idiomatic-cast.mjs";
+import inferable_type_predicate_default from "./inferable-type-predicate.mjs";
+import inner_as_const_default from "./inner-as-const.mjs";
+import jsx_tostring_default from "./jsx-tostring.mjs";
+import literal_destructuring_default from "./literal-destructuring.mjs";
+import named_export_with_side_effects_default from "./named-export-with-side-effects.mjs";
+import nested_reduce_default from "./nested-reduce.mjs";
+import nested_try_catch_default from "./nested-try-catch.mjs";
+import no_commented_out_comment_default from "./no-commented-out-comment.mjs";
 import no_constant_template_expression_default from "./no-constant-template-expression.mjs";
+import no_constructed_error_cause_default from "./no-constructed-error-cause.mjs";
+import no_convoluted_boolean_expressions_default from "./no-convoluted-boolean-expressions.mjs";
 import no_convoluted_logical_expressions_default from "./no-convoluted-logical-expressions.mjs";
 import no_custom_url_parsing_default from "./no-custom-url-parsing.mjs";
 import no_disallowed_warning_comments_default from "./no-disallowed-warning-comments.mjs";
 import no_duplicated_return_default from "./no-duplicated-return.mjs";
 import no_else_break_default from "./no-else-break.mjs";
 import no_else_continue_default from "./no-else-continue.mjs";
+import no_else_never_default from "./no-else-never.mjs";
 import no_else_return_default from "./no-else-return.mjs";
 import no_else_throw_default from "./no-else-throw.mjs";
 import no_empty_attribute_default from "./no-empty-attribute.mjs";
@@ -21,10 +48,15 @@ import no_extra_nested_boolean_cast_default from "./no-extra-nested-boolean-cast
 import no_first_last_default from "./no-first-last.mjs";
 import no_float_length_check_default from "./no-float-length-check.mjs";
 import no_huge_try_block_default from "./no-huge-try-block.mjs";
+import no_huge_useeffect_default from "./no-huge-useeffect.mjs";
+import no_if_length_for_default from "./no-if-length-for.mjs";
 import no_inline_jsdoc_tag_default from "./no-inline-jsdoc-tag.mjs";
 import no_invalid_date_literal_default from "./no-invalid-date-literal.mjs";
 import no_jsx_statement_default from "./no-jsx-statement.mjs";
+import no_lax_array_type_default from "./no-lax-array-type.mjs";
+import no_lax_return_type_default from "./no-lax-return-type.mjs";
 import no_mutable_literal_fill_default from "./no-mutable-literal-fill.mjs";
+import no_nullish_ternary_default from "./no-nullish-ternary.mjs";
 import no_numbered_comments_default from "./no-numbered-comments.mjs";
 import no_obvious_any_default from "./no-obvious-any.mjs";
 import no_optional_type_guard_param_default from "./no-optional-type-guard-param.mjs";
@@ -36,39 +68,88 @@ import no_self_object_assign_default from "./no-self-object-assign.mjs";
 import no_sloppy_length_check_default from "./no-sloppy-length-check.mjs";
 import no_suspicious_jsx_semicolon_default from "./no-suspicious-jsx-semicolon.mjs";
 import no_ternary_return_default from "./no-ternary-return.mjs";
+import no_type_guard_default from "./no-type-guard.mjs";
 import no_unassigned_todo_default from "./no-unassigned-todo.mjs";
 import no_unbound_catch_error_default from "./no-unbound-catch-error.mjs";
+import no_unused_mutually_referential_default from "./no-unused-mutually-referential.mjs";
 import no_unused_param_read_default from "./no-unused-param-read.mjs";
 import no_useless_computed_key_default from "./no-useless-computed-key.mjs";
 import no_useless_iife_default from "./no-useless-iife.mjs";
 import no_useless_logical_fallback_default from "./no-useless-logical-fallback.mjs";
 import no_useless_return_undefined_default from "./no-useless-return-undefined.mjs";
+import no_useless_ts_check_default from "./no-useless-ts-check.mjs";
 import no_useless_use_strict_default from "./no-useless-use-strict.mjs";
 import no_useless_usememo_default from "./no-useless-usememo.mjs";
 import no_whitespace_property_default from "./no-whitespace-property.mjs";
+import nullish_object_spread_default from "./nullish-object-spread.mjs";
 import optional_call_expression_default from "./optional-call-expression.mjs";
+import prefer_array_from_default from "./prefer-array-from.mjs";
 import prefer_catch_method_default from "./prefer-catch-method.mjs";
 import prefer_early_return_default from "./prefer-early-return.mjs";
+import prefer_eqeq_null_default from "./prefer-eqeq-null.mjs";
+import prefer_finally_default from "./prefer-finally.mjs";
+import prefer_getorinsert_default from "./prefer-getorinsert.mjs";
+import prefer_has_default from "./prefer-has.mjs";
+import prefer_in_default from "./prefer-in.mjs";
+import prefer_object_keys_values_default from "./prefer-object-keys-values.mjs";
 import prefer_repeat_default from "./prefer-repeat.mjs";
+import prefer_satisfies_default from "./prefer-satisfies.mjs";
+import prefer_string_join_default from "./prefer-string-join.mjs";
 import primitive_valueof_default from "./primitive-valueof.mjs";
+import slim_try_default from "./slim-try.mjs";
+import styled_button_has_type_default from "./styled-button-has-type.mjs";
+import styled_transient_props_default from "./styled-transient-props.mjs";
 import suspicious_map_length_default from "./suspicious-map-length.mjs";
+import template_tostring_default from "./template-tostring.mjs";
 import unsafe_asserted_chain_default from "./unsafe-asserted-chain.mjs";
 import unused_object_assign_default from "./unused-object-assign.mjs";
+import unused_object_freeze_default from "./unused-object-freeze.mjs";
+import useless_as_const_default from "./useless-as-const.mjs";
+import useless_assign_default from "./useless-assign.mjs";
+import useless_conditional_assign_default from "./useless-conditional-assign.mjs";
 import useless_intermediary_variable_default from "./useless-intermediary-variable.mjs";
-
+import useless_mock_default from "./useless-mock.mjs";
+import useless_required_default from "./useless-required.mjs";
 //#region lib/rules/index.ts
 var rules_exports = /* @__PURE__ */ __exportAll({
+	"array-from-array": () => array_from_array_default,
+	"as-unknown-as": () => as_unknown_as_default,
+	"await-promise-resolve": () => await_promise_resolve_default,
+	"boolean-coalescing": () => boolean_coalescing_default,
+	"comment-duplicate-leading-space": () => comment_duplicate_leading_space_default,
+	"conditional-boolean": () => conditional_boolean_default,
+	"constant-boolean-cast": () => constant_boolean_cast_default,
 	"de-morgan": () => de_morgan_default,
+	"discarded-expression-statement": () => discarded_expression_statement_default,
 	"distribute-boolean-casts": () => distribute_boolean_casts_default,
 	"duplicate-destructuring": () => duplicate_destructuring_default,
+	"duplicate-object-spread": () => duplicate_object_spread_default,
+	e: () => e_default,
+	"empty-for": () => empty_for_default,
+	"enum-member": () => enum_member_default,
+	"eqeq-null": () => eqeq_null_default,
+	"exact-string-regex": () => exact_string_regex_default,
+	"export-using": () => export_using_default,
+	"generic-constructor-with-hook": () => generic_constructor_with_hook_default,
 	"idiomatic-cast": () => idiomatic_cast_default,
+	"inferable-type-predicate": () => inferable_type_predicate_default,
+	"inner-as-const": () => inner_as_const_default,
+	"jsx-tostring": () => jsx_tostring_default,
+	"literal-destructuring": () => literal_destructuring_default,
+	"named-export-with-side-effects": () => named_export_with_side_effects_default,
+	"nested-reduce": () => nested_reduce_default,
+	"nested-try-catch": () => nested_try_catch_default,
+	"no-commented-out-comment": () => no_commented_out_comment_default,
 	"no-constant-template-expression": () => no_constant_template_expression_default,
+	"no-constructed-error-cause": () => no_constructed_error_cause_default,
+	"no-convoluted-boolean-expressions": () => no_convoluted_boolean_expressions_default,
 	"no-convoluted-logical-expressions": () => no_convoluted_logical_expressions_default,
 	"no-custom-url-parsing": () => no_custom_url_parsing_default,
 	"no-disallowed-warning-comments": () => no_disallowed_warning_comments_default,
 	"no-duplicated-return": () => no_duplicated_return_default,
 	"no-else-break": () => no_else_break_default,
 	"no-else-continue": () => no_else_continue_default,
+	"no-else-never": () => no_else_never_default,
 	"no-else-return": () => no_else_return_default,
 	"no-else-throw": () => no_else_throw_default,
 	"no-empty-attribute": () => no_empty_attribute_default,
@@ -80,10 +161,15 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	"no-first-last": () => no_first_last_default,
 	"no-float-length-check": () => no_float_length_check_default,
 	"no-huge-try-block": () => no_huge_try_block_default,
+	"no-huge-useeffect": () => no_huge_useeffect_default,
+	"no-if-length-for": () => no_if_length_for_default,
 	"no-inline-jsdoc-tag": () => no_inline_jsdoc_tag_default,
 	"no-invalid-date-literal": () => no_invalid_date_literal_default,
 	"no-jsx-statement": () => no_jsx_statement_default,
+	"no-lax-array-type": () => no_lax_array_type_default,
+	"no-lax-return-type": () => no_lax_return_type_default,
 	"no-mutable-literal-fill": () => no_mutable_literal_fill_default,
+	"no-nullish-ternary": () => no_nullish_ternary_default,
 	"no-numbered-comments": () => no_numbered_comments_default,
 	"no-obvious-any": () => no_obvious_any_default,
 	"no-optional-type-guard-param": () => no_optional_type_guard_param_default,
@@ -95,26 +181,48 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	"no-sloppy-length-check": () => no_sloppy_length_check_default,
 	"no-suspicious-jsx-semicolon": () => no_suspicious_jsx_semicolon_default,
 	"no-ternary-return": () => no_ternary_return_default,
+	"no-type-guard": () => no_type_guard_default,
 	"no-unassigned-todo": () => no_unassigned_todo_default,
 	"no-unbound-catch-error": () => no_unbound_catch_error_default,
+	"no-unused-mutually-referential": () => no_unused_mutually_referential_default,
 	"no-unused-param-read": () => no_unused_param_read_default,
 	"no-useless-computed-key": () => no_useless_computed_key_default,
 	"no-useless-iife": () => no_useless_iife_default,
 	"no-useless-logical-fallback": () => no_useless_logical_fallback_default,
 	"no-useless-return-undefined": () => no_useless_return_undefined_default,
+	"no-useless-ts-check": () => no_useless_ts_check_default,
 	"no-useless-use-strict": () => no_useless_use_strict_default,
 	"no-useless-usememo": () => no_useless_usememo_default,
 	"no-whitespace-property": () => no_whitespace_property_default,
+	"nullish-object-spread": () => nullish_object_spread_default,
 	"optional-call-expression": () => optional_call_expression_default,
+	"prefer-array-from": () => prefer_array_from_default,
 	"prefer-catch-method": () => prefer_catch_method_default,
 	"prefer-early-return": () => prefer_early_return_default,
+	"prefer-eqeq-null": () => prefer_eqeq_null_default,
+	"prefer-finally": () => prefer_finally_default,
+	"prefer-getorinsert": () => prefer_getorinsert_default,
+	"prefer-has": () => prefer_has_default,
+	"prefer-in": () => prefer_in_default,
+	"prefer-object-keys-values": () => prefer_object_keys_values_default,
 	"prefer-repeat": () => prefer_repeat_default,
+	"prefer-satisfies": () => prefer_satisfies_default,
+	"prefer-string-join": () => prefer_string_join_default,
 	"primitive-valueof": () => primitive_valueof_default,
+	"slim-try": () => slim_try_default,
+	"styled-button-has-type": () => styled_button_has_type_default,
+	"styled-transient-props": () => styled_transient_props_default,
 	"suspicious-map-length": () => suspicious_map_length_default,
+	"template-tostring": () => template_tostring_default,
 	"unsafe-asserted-chain": () => unsafe_asserted_chain_default,
 	"unused-object-assign": () => unused_object_assign_default,
-	"useless-intermediary-variable": () => useless_intermediary_variable_default
+	"unused-object-freeze": () => unused_object_freeze_default,
+	"useless-as-const": () => useless_as_const_default,
+	"useless-assign": () => useless_assign_default,
+	"useless-conditional-assign": () => useless_conditional_assign_default,
+	"useless-intermediary-variable": () => useless_intermediary_variable_default,
+	"useless-mock": () => useless_mock_default,
+	"useless-required": () => useless_required_default
 });
-
 //#endregion
-export { rules_exports };
+export { rules_exports };

package/dist/rules/inferable-type-predicate.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/inferable-type-predicate.d.ts
+declare const _default: ESLintUtils.RuleModule<"noInferableTypePredicate", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/inferable-type-predicate.mjs

@@ -0,0 +1,100 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Option, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+//#region lib/rules/inferable-type-predicate.ts
+const { name } = path.parse(import.meta.filename);
+var inferable_type_predicate_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid inferable type predicates",
+			strict: true,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noInferableTypePredicate: "Since TypeScript 5.5, this type predicate can be automatically inferred. You should remove it." }
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		return {
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction,
+			ArrowFunctionExpression: checkFunction
+		};
+		function checkFunction(fn) {
+			const { returnType } = fn;
+			if (!returnType) return;
+			if (returnType.typeAnnotation.type !== AST_NODE_TYPES.TSTypePredicate) return;
+			const [param] = fn.params;
+			if (!param) return;
+			if (param.type !== AST_NODE_TYPES.Identifier) return;
+			const maybeReturnValue = getReturnValue(fn.body);
+			if (!maybeReturnValue.some) return;
+			const returnValue = maybeReturnValue.value;
+			if (!isInferableEquality(returnValue, param) && !isInferableInequality(returnValue, param)) return;
+			context.report({
+				node: fn,
+				messageId: "noInferableTypePredicate",
+				fix(fixer) {
+					return fixer.remove(returnType);
+				}
+			});
+		}
+		function isInferableInequality(expr, param) {
+			if (expr.type !== AST_NODE_TYPES.BinaryExpression) return false;
+			if (expr.operator !== "!==" && expr.operator !== "!=") return false;
+			if (!getServices().getTypeAtLocation(param).isUnion()) return false;
+			return isLiteralInequality(expr.left, expr.right, param) || isLiteralInequality(expr.right, expr.left, param);
+		}
+	}
+});
+function isInferableEquality(expr, param) {
+	if (expr.type !== AST_NODE_TYPES.BinaryExpression) return false;
+	if (expr.operator !== "===") return false;
+	return isTypeOfCheck(expr.left, expr.right, param) || isTypeOfCheck(expr.right, expr.left, param) || isLiteralEquality(expr.left, expr.right, param) || isLiteralEquality(expr.right, expr.left, param);
+}
+function isTypeOfCheck(left, right, ident) {
+	if (left.type !== AST_NODE_TYPES.UnaryExpression) return false;
+	if (left.operator !== "typeof") return false;
+	if (left.argument.type !== AST_NODE_TYPES.Identifier) return false;
+	if (left.argument.name !== ident.name) return false;
+	if (right.type !== AST_NODE_TYPES.Literal) return false;
+	if (typeof right.value !== "string") return false;
+	return true;
+}
+function isLiteralInequality(left, right, ident) {
+	if (left.type !== AST_NODE_TYPES.Identifier) return false;
+	if (left.name !== ident.name) return false;
+	switch (right.type) {
+		case AST_NODE_TYPES.Literal: return right.value === null;
+		case AST_NODE_TYPES.Identifier: return right.name === "undefined";
+		default: return false;
+	}
+}
+function isLiteralEquality(left, right, ident) {
+	if (left.type !== AST_NODE_TYPES.Identifier) return false;
+	if (left.name !== ident.name) return false;
+	switch (right.type) {
+		case AST_NODE_TYPES.Literal: return true;
+		case AST_NODE_TYPES.Identifier: return right.name === "undefined";
+		default: return false;
+	}
+}
+function getReturnValue(body) {
+	if (body.type !== AST_NODE_TYPES.BlockStatement) return Some(body);
+	if (body.body.length !== 1) return None;
+	const returnStatement = body.body.find((stmt) => stmt.type === AST_NODE_TYPES.ReturnStatement);
+	if (!returnStatement) return None;
+	if (!returnStatement.argument) return None;
+	return Option.fromUndef(returnStatement.argument);
+}
+//#endregion
+export { inferable_type_predicate_default as default };

package/dist/rules/inner-as-const.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/inner-as-const.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noInnerAsConstObject" | "noInnerAsConstArray", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/inner-as-const.mjs

@@ -0,0 +1,70 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/inner-as-const.ts
+const { name } = path.parse(import.meta.filename);
+var inner_as_const_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce setting `as const` on the outermost object/array literal only",
+			strict: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			noInnerAsConstObject: "Only set `as const` on the outermost object",
+			noInnerAsConstArray: "Only set `as const` on the outermost array"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			ArrayExpression(node) {
+				for (const elt of node.elements) {
+					if (!elt) continue;
+					const maybeExpr = getAsConstExpr(elt);
+					if (!maybeExpr.some) continue;
+					const expr = maybeExpr.value;
+					context.report({
+						node: elt,
+						messageId: "noInnerAsConstArray",
+						*fix(fixer) {
+							yield fixer.replaceText(elt, context.sourceCode.getText(expr));
+							if (getAsConstExpr(node.parent).some) return;
+							yield fixer.insertTextAfter(node, " as const");
+						}
+					});
+				}
+			},
+			ObjectExpression(node) {
+				for (const prop of node.properties) {
+					if (prop.type === AST_NODE_TYPES.SpreadElement) continue;
+					const maybeExpr = getAsConstExpr(prop.value);
+					if (!maybeExpr.some) continue;
+					const expr = maybeExpr.value;
+					context.report({
+						node: prop,
+						messageId: "noInnerAsConstObject",
+						*fix(fixer) {
+							yield fixer.replaceText(prop.value, context.sourceCode.getText(expr));
+							if (getAsConstExpr(node.parent).some) return;
+							yield fixer.insertTextAfter(node, " as const");
+						}
+					});
+				}
+			}
+		};
+	}
+});
+function getAsConstExpr(node) {
+	if (node.type !== AST_NODE_TYPES.TSAsExpression) return None;
+	if (node.typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) return None;
+	if (node.typeAnnotation.typeName.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.typeAnnotation.typeName.name !== "const") return None;
+	return Some(node.expression);
+}
+//#endregion
+export { inner_as_const_default as default };

package/dist/rules/jsx-tostring.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/jsx-tostring.d.ts
+declare const _default: ESLintUtils.RuleModule<"noToString", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/jsx-tostring.mjs

@@ -0,0 +1,120 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some, getFirstOption } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+//#region lib/rules/jsx-tostring.ts
+const { name } = path.parse(import.meta.filename);
+var jsx_tostring_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid calling `.toString()` inside JSX expressions containers",
+			strict: true,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noToString: "Calling `.toString()` is unnecessary here" }
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		let checker;
+		function getChecker() {
+			checker ??= getServices().program.getTypeChecker();
+			return checker;
+		}
+		return { JSXExpressionContainer(node) {
+			checkJsxExpression(node);
+		} };
+		function checkJsxExpression(container) {
+			const { expression } = container;
+			if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) return;
+			const maybeObj = getToString(expression);
+			if (!maybeObj.some) return;
+			const obj = maybeObj.value;
+			const objType = getServices().getTypeAtLocation(obj);
+			const { parent } = container;
+			if (parent.type === AST_NODE_TYPES.JSXFragment) {
+				context.report({
+					node: expression,
+					messageId: "noToString",
+					fix(fixer) {
+						const txt = context.sourceCode.getText(obj);
+						return fixer.replaceText(expression, txt);
+					}
+				});
+				return;
+			}
+			if (parent.type !== AST_NODE_TYPES.JSXElement) return;
+			const { openingElement } = parent;
+			if (openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(openingElement.name.name)) {
+				context.report({
+					node: expression,
+					messageId: "noToString",
+					fix(fixer) {
+						const txt = context.sourceCode.getText(obj);
+						return fixer.replaceText(expression, txt);
+					}
+				});
+				return;
+			}
+			const maybeChildrenType = getChildrenPropTypeFromComponentType(getServices().getTypeAtLocation(openingElement.name));
+			if (!maybeChildrenType.some) return;
+			const childrenType = maybeChildrenType.value;
+			if (!isAssignableTo(objType, childrenType)) return;
+			context.report({
+				node: expression,
+				messageId: "noToString",
+				fix(fixer) {
+					const txt = context.sourceCode.getText(obj);
+					return fixer.replaceText(expression, txt);
+				}
+			});
+		}
+		function getChildrenPropTypeFromComponentType(type) {
+			return getFirstOption([getChildrenTypeFromSignatures(type.getCallSignatures()), getChildrenTypeFromSignatures(type.getConstructSignatures())]);
+		}
+		function getChildrenTypeFromSignatures(signatures) {
+			for (const signature of signatures) {
+				const maybeChildrenType = getChildrenTypeFromSignature(signature);
+				if (!maybeChildrenType.some) continue;
+				return maybeChildrenType;
+			}
+			return None;
+		}
+		function getChildrenTypeFromSignature(signature) {
+			const [param] = signature.getParameters();
+			if (!param) return None;
+			const paramType = getValueTypeFromSymbol(param);
+			/* v8 ignore if -- @preserve */
+			if (!paramType) return None;
+			const childrenProp = paramType.getProperty("children");
+			if (!childrenProp) return None;
+			const childrenType = getValueTypeFromSymbol(childrenProp);
+			if (childrenType) return Some(childrenType);
+			return None;
+		}
+		function getValueTypeFromSymbol(symbol) {
+			if (!symbol.valueDeclaration) return null;
+			return getChecker().getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
+		}
+		function isAssignableTo(source, target) {
+			return getChecker().isTypeAssignableTo(source, getChecker().getWidenedType(target));
+		}
+	}
+});
+function getToString(expr) {
+	if (expr.type !== AST_NODE_TYPES.CallExpression) return None;
+	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 !== "toString") return None;
+	return Some(expr.callee.object);
+}
+//#endregion
+export { jsx_tostring_default as default };

package/dist/rules/literal-destructuring.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/literal-destructuring.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"uselessSpreadElement" | "uselessSpreadProperty" | "usePlainDeclaration", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/literal-destructuring.mjs

@@ -0,0 +1,102 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/literal-destructuring.ts
+const { name } = path.parse(import.meta.filename);
+var literal_destructuring_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid variable declaration by destructuring object or array literals",
+			strict: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			uselessSpreadElement: "Remove this spread element from the array literal, it is most likely useless since its value is never read.",
+			uselessSpreadProperty: "Remove this spread property from the object literal, it is most likely useless since its value is never read.",
+			usePlainDeclaration: "Use a plain variable declaration instead of destructuring a literal"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { VariableDeclarator(node) {
+			if (!node.init) return;
+			if (node.id.type === AST_NODE_TYPES.ArrayPattern && node.init.type === AST_NODE_TYPES.ArrayExpression) {
+				checkArrayDecl(node, node.id, node.init);
+				return;
+			}
+			if (node.id.type === AST_NODE_TYPES.ObjectPattern && node.init.type === AST_NODE_TYPES.ObjectExpression) checkObjectDecl(node, node.id, node.init);
+		} };
+		function checkArrayDecl(decl, id, init) {
+			const spreadElement = init.elements.find((elt) => elt?.type === AST_NODE_TYPES.SpreadElement);
+			if (spreadElement) {
+				const idx = init.elements.indexOf(spreadElement);
+				if (idx >= id.elements.length) context.report({
+					node: spreadElement,
+					messageId: "uselessSpreadElement",
+					*fix(fixer) {
+						yield fixer.remove(spreadElement);
+						const commaToken = context.sourceCode.getTokenAfter(spreadElement);
+						if (idx === 0 && commaToken?.type === AST_TOKEN_TYPES.Punctuator && commaToken.value === ",") yield fixer.remove(commaToken);
+					}
+				});
+				return;
+			}
+			if (!id.elements.every((elt) => elt?.type === AST_NODE_TYPES.Identifier)) return;
+			if (!init.elements.every((elt) => elt?.type !== AST_NODE_TYPES.SpreadElement)) return;
+			const entries = id.elements.map((ident, i) => [ident.name, init.elements.filter((elt) => elt?.type !== AST_NODE_TYPES.SpreadElement).at(i)]);
+			context.report({
+				node: decl,
+				messageId: "usePlainDeclaration",
+				fix(fixer) {
+					const txt = entries.map(([key, value]) => {
+						return `${key} = ${value ? context.sourceCode.getText(value) : "undefined"}`;
+					}).join(", ");
+					return fixer.replaceText(decl, txt);
+				}
+			});
+		}
+		function checkObjectDecl(decl, id, init) {
+			if (!id.properties.every((prop) => prop.type === AST_NODE_TYPES.Property)) return;
+			if (id.properties.some((prop) => prop.computed)) return;
+			const patternKeys = id.properties.map((prop) => prop.key);
+			if (!patternKeys.every((key) => key.type === AST_NODE_TYPES.Identifier)) return;
+			const patternNames = patternKeys.map((key) => key.name);
+			for (const initProp of init.properties) {
+				if (initProp.type === AST_NODE_TYPES.Property) {
+					if (initProp.computed) return;
+					continue;
+				}
+				const idx = init.properties.indexOf(initProp);
+				const subsequentPropertyNames = new Set(init.properties.slice(idx).filter((prop) => prop.type === AST_NODE_TYPES.Property).map((prop) => prop.key).filter((key) => key.type === AST_NODE_TYPES.Identifier).map((key) => key.name));
+				if (patternNames.every((patternName) => subsequentPropertyNames.has(patternName))) context.report({
+					node: initProp,
+					messageId: "uselessSpreadProperty",
+					*fix(fixer) {
+						yield fixer.remove(initProp);
+						const commaToken = context.sourceCode.getTokenAfter(initProp);
+						if (idx === 0 && commaToken?.type === AST_TOKEN_TYPES.Punctuator && commaToken.value === ",") yield fixer.remove(commaToken);
+					}
+				});
+				return;
+			}
+			const initMap = new Map(init.properties.filter((prop) => prop.type === AST_NODE_TYPES.Property).map((prop) => [prop.key, prop.value]).filter((entry) => entry[0].type === AST_NODE_TYPES.Identifier).map(([key, value]) => [key.name, value]));
+			const entries = patternNames.map((patternName) => [patternName, initMap.get(patternName)]);
+			if (!entries.every((entry) => entry[1] !== void 0)) return;
+			context.report({
+				node: decl,
+				messageId: "usePlainDeclaration",
+				fix(fixer) {
+					const txt = entries.map(([key, value]) => {
+						return `${key} = ${context.sourceCode.getText(value)}`;
+					}).join(", ");
+					return fixer.replaceText(decl, txt);
+				}
+			});
+		}
+	}
+});
+//#endregion
+export { literal_destructuring_default as default };

package/dist/rules/named-export-with-side-effects.d.mts

@@ -0,0 +1,11 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/named-export-with-side-effects.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"namedExportWithSideEffects", [{
+  strict: boolean;
+}], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };