eslint-plugin-wyrm 0.0.10 → 0.0.13

package/dist/rules/prefer-in.mjs

@@ -0,0 +1,81 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some, getFirstOption } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/prefer-in.ts
+/**
+* @fileoverview
+*
+* `x in y` does not have the same behavior as `Object.hasOwn(y, x)` and `Object.prototype.hasOwnProperty.call(y, x)`.
+*
+* But in the majority of cases, the difference does not really matter (modern codebases should already avoid objects with prototype chains anyway).
+*
+* `x in y` is also more readable and better supported in TypeScript flow analysis for type narrowing.
+*/
+const { name } = path.parse(import.meta.filename);
+var prefer_in_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer `in` to `Object.hasOwn()` and `Object.prototype.hasOwnProperty.call()`",
+			strict: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			preferIn: "See if you can use `in` instead",
+			useIn: "Use `in`"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { CallExpression(node) {
+			const maybeArgs = getFirstOption([getObjectHasOwn(node), getHasOwnPropertyCall(node)]);
+			if (!maybeArgs.some) return;
+			const [key, value] = maybeArgs.value;
+			context.report({
+				node,
+				messageId: "preferIn",
+				suggest: [{
+					messageId: "useIn",
+					fix(fixer) {
+						const keyText = context.sourceCode.getText(key);
+						const valueText = context.sourceCode.getText(value);
+						return fixer.replaceText(node, `${keyText} in ${valueText}`);
+					}
+				}]
+			});
+		} };
+	}
+});
+function getObjectHasOwn(node) {
+	if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (node.callee.object.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.callee.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.callee.object.name !== "Object") return None;
+	if (node.callee.property.name !== "hasOwn") return None;
+	const [arg1, arg2] = node.arguments;
+	if (!arg1) return None;
+	if (!arg2) return None;
+	return Some([arg2, arg1]);
+}
+function getHasOwnPropertyCall(node) {
+	if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (node.callee.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.callee.property.name !== "call") return None;
+	if (node.callee.object.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (node.callee.object.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.callee.object.property.name !== "hasOwnProperty") return None;
+	if (node.callee.object.object.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (node.callee.object.object.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.callee.object.object.property.name !== "prototype") return None;
+	if (node.callee.object.object.object.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.callee.object.object.object.name !== "Object") return None;
+	const [arg1, arg2] = node.arguments;
+	if (!arg1) return None;
+	if (!arg2) return None;
+	return Some([arg2, arg1]);
+}
+//#endregion
+export { prefer_in_default as default };

package/dist/rules/prefer-object-keys-values.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/prefer-object-keys-values.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"preferObjectKeys" | "preferObjectValues" | "useObjectKeys" | "useObjectValues", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/prefer-object-keys-values.mjs

@@ -0,0 +1,78 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/prefer-object-keys-values.ts
+const { name } = path.parse(import.meta.filename);
+var prefer_object_keys_values_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce using `Object.keys()` and `Object.values()` rather than `Object.entries()`",
+			strict: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			preferObjectKeys: "You are only using keys, use `Object.keys()` instead",
+			preferObjectValues: "You are only using values, use `Object.values()` instead",
+			useObjectKeys: "Use `Object.keys()`",
+			useObjectValues: "Use `Object.values()`"
+		}
+	},
+	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 (node.callee.object.type !== AST_NODE_TYPES.CallExpression) return;
+			if (node.callee.object.callee.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (node.callee.object.callee.object.type !== AST_NODE_TYPES.Identifier) return;
+			if (node.callee.object.callee.property.type !== AST_NODE_TYPES.Identifier) return;
+			if (node.callee.object.callee.object.name !== "Object") return;
+			const objectMethod = node.callee.object.callee.property;
+			if (objectMethod.name !== "entries") return;
+			if (![
+				"map",
+				"forEach",
+				"every",
+				"some"
+			].includes(node.callee.property.name)) return;
+			const [arg] = node.arguments;
+			if (!arg) return;
+			if (arg.type !== AST_NODE_TYPES.FunctionExpression && arg.type !== AST_NODE_TYPES.ArrowFunctionExpression) return;
+			const [param] = arg.params;
+			if (!param) return;
+			if (param.type !== AST_NODE_TYPES.ArrayPattern) return;
+			const [keyParam, valueParam, ...rest] = param.elements;
+			if (rest.length) return;
+			if (!valueParam && keyParam?.type === AST_NODE_TYPES.Identifier) {
+				context.report({
+					node,
+					messageId: "preferObjectKeys",
+					suggest: [{
+						messageId: "useObjectKeys",
+						*fix(fixer) {
+							yield fixer.replaceText(objectMethod, "keys");
+							yield fixer.replaceText(param, keyParam.name);
+						}
+					}]
+				});
+				return;
+			}
+			if (keyParam === null && valueParam?.type === AST_NODE_TYPES.Identifier) context.report({
+				node,
+				messageId: "preferObjectValues",
+				suggest: [{
+					messageId: "useObjectValues",
+					*fix(fixer) {
+						yield fixer.replaceText(objectMethod, "values");
+						yield fixer.replaceText(param, valueParam.name);
+					}
+				}]
+			});
+		} };
+	}
+});
+//#endregion
+export { prefer_object_keys_values_default as default };

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

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint85 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/prefer-repeat.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint85.RuleModule<"preferRepeat" | "replaceByRepeat", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint85.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"preferRepeat" | "replaceByRepeat", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/prefer-repeat.mjs

@@ -2,7 +2,6 @@ import { createRule } from "../utils/createRule.mjs";
 import { None, Option, Some } from "../utils/option.mjs";
 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({
@@ -88,13 +87,11 @@ function extractRepeatedStringFromTemplateLiteral(expr, acc) {
 		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;
 	const nonEmptyQuasis = expr.quasis.map((q) => q.value.cooked).filter(Boolean);
 	const firstQuasi = nonEmptyQuasis.at(0);
 	if (!firstQuasi) return None;
-	if (nonEmptyQuasis.length === 1) return Some(firstQuasi);
 	if (nonEmptyQuasis.every((quasi) => quasi === firstQuasi)) return Some(firstQuasi.repeat(nonEmptyQuasis.length));
 	return None;
 }
@@ -106,6 +103,5 @@ function extractRepeatedStringFromCallExpression(expr, acc) {
 	if (expr.callee.object.name !== acc.name) return None;
 	return Option.fromUndef(expr.arguments[0]);
 }
-
 //#endregion
-export { prefer_repeat_default as default };
+export { prefer_repeat_default as default };

package/dist/rules/prefer-satisfies.d.mts

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

package/dist/rules/prefer-satisfies.mjs

@@ -0,0 +1,86 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+//#region lib/rules/prefer-satisfies.ts
+const { name } = path.parse(import.meta.filename);
+var prefer_satisfies_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer `satisfies` to type assertions",
+			strict: true,
+			requiresTypeChecking: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: { preferSatisfies: "Use `satisfies` instead of `as`" }
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		let checker;
+		function getChecker() {
+			checker ??= getServices().program.getTypeChecker();
+			return checker;
+		}
+		return { TSAsExpression(node) {
+			if (node.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const") return;
+			const assertedType = getServices().getTypeFromTypeNode(node.typeAnnotation);
+			if (hasOptionalProperties(assertedType)) return;
+			if (getObjectValueTypes(assertedType, getChecker()).some((t) => hasOptionalProperties(t))) return;
+			if (getChecker().getIndexInfoOfType(assertedType, ts.IndexKind.String) !== void 0) return;
+			if (isPromiseType(assertedType)) return;
+			const flags = ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never | ts.TypeFlags.EnumLike;
+			if (assertedType.getFlags() & flags) return;
+			const exprType = getServices().getTypeAtLocation(node.expression);
+			if (exprType.getFlags() & flags) return;
+			if (isPromiseType(exprType)) return;
+			if (!exprType.getProperties().length) return;
+			if (!getChecker().isTypeAssignableTo(exprType, assertedType)) return;
+			if (!getChecker().isTypeAssignableTo(assertedType, exprType)) return;
+			context.report({
+				node,
+				messageId: "preferSatisfies",
+				suggest: [{
+					messageId: "preferSatisfies",
+					fix(fixer) {
+						const asToken = context.sourceCode.getTokenBefore(node.typeAnnotation);
+						return fixer.replaceText(asToken, "satisfies");
+					}
+				}]
+			});
+		} };
+	}
+});
+function isPromiseType(type) {
+	return type.getSymbol()?.getName() === "Promise";
+}
+function getObjectValueTypes(type, checker) {
+	if (type.isUnionOrIntersection()) return type.types.flatMap((t) => getObjectValueTypes(t, checker));
+	if (!isObjectType(type)) return [];
+	return checker.getPropertiesOfType(type).map((prop) => checker.getTypeOfSymbol(prop));
+}
+function hasOptionalProperties(type) {
+	if (type.isUnionOrIntersection()) return type.types.some((t) => hasOptionalProperties(t));
+	if (!isObjectType(type)) return type.isTypeParameter();
+	const maybeMappedOptional = getOptionalMappedType(type);
+	if (maybeMappedOptional.some) return maybeMappedOptional.value;
+	return type.getProperties().some((prop) => (prop.flags & ts.SymbolFlags.Optional) !== 0);
+}
+function isObjectType(type) {
+	return (type.getFlags() & ts.TypeFlags.Object) !== 0;
+}
+function getOptionalMappedType(type) {
+	if ((type.objectFlags & ts.ObjectFlags.Mapped) === 0) return None;
+	if ((type.objectFlags & ts.ObjectFlags.Instantiated) !== 0) return None;
+	return Some(!!type.getSymbol()?.declarations?.some((decl) => ts.isMappedTypeNode(decl) && decl.questionToken));
+}
+//#endregion
+export { prefer_satisfies_default as default };

package/dist/rules/prefer-string-join.d.mts

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

package/dist/rules/prefer-string-join.mjs

@@ -0,0 +1,67 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Option, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { ASTUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/prefer-string-join.ts
+const { name } = path.parse(import.meta.filename);
+var prefer_string_join_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce usage of `String.prototype.join`",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { preferJoin: "This could be simplified as `{{fixed}}`" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { ForOfStatement(node) {
+			const maybeStmt = getUniqueStatement(node.body);
+			if (!maybeStmt.some) return;
+			const stmt = maybeStmt.value;
+			if (stmt.type !== AST_NODE_TYPES.ExpressionStatement) return;
+			if (stmt.expression.type !== AST_NODE_TYPES.AssignmentExpression) return;
+			if (stmt.expression.operator !== "+=") return;
+			if (stmt.expression.left.type !== AST_NODE_TYPES.Identifier) return;
+			if (stmt.expression.right.type !== AST_NODE_TYPES.Identifier) return;
+			const scope = context.sourceCode.getScope(node);
+			const leftDef = findDef(scope, stmt.expression.left);
+			if (!leftDef) return;
+			if (leftDef.node.type !== AST_NODE_TYPES.VariableDeclarator) return;
+			const { init } = leftDef.node;
+			if (!init) return;
+			if (init.type !== AST_NODE_TYPES.Literal) return;
+			const initValue = init.value;
+			if (typeof initValue !== "string") return;
+			const rightDef = findDef(scope, stmt.expression.right);
+			if (!rightDef) return;
+			if (rightDef.node.parent !== node.left) return;
+			const stringsTxt = context.sourceCode.getText(node.right);
+			const initTxt = context.sourceCode.getText(init);
+			const fixed = `${stringsTxt}.join()`;
+			const txt = initValue ? `${initTxt}.concat(${fixed})` : fixed;
+			context.report({
+				node,
+				messageId: "preferJoin",
+				data: { fixed },
+				*fix(fixer) {
+					yield fixer.replaceText(init, txt);
+					yield fixer.remove(node);
+				}
+			});
+		} };
+	}
+});
+function findDef(scope, ident) {
+	return ASTUtils.findVariable(scope, ident)?.defs.at(-1);
+}
+function getUniqueStatement(stmt) {
+	if (stmt.type !== AST_NODE_TYPES.BlockStatement) return Some(stmt);
+	if (stmt.body.length !== 1) return None;
+	return Option.fromUndef(stmt.body[0]);
+}
+//#endregion
+export { prefer_string_join_default as default };

package/dist/rules/primitive-valueof.mjs

@@ -1,8 +1,7 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-
+import * as ts$1 from "typescript";
 //#region lib/rules/primitive-valueof.ts
 const { name } = path.parse(import.meta.filename);
 var primitive_valueof_default = createRule({
@@ -39,12 +38,11 @@ var primitive_valueof_default = createRule({
 });
 function isPrimitiveOnly(type) {
 	if (type.isUnion()) return type.types.every((t) => isPrimitiveOnly(t));
-	if (type.flags & ts.TypeFlags.NumberLike) return true;
-	if (type.flags & ts.TypeFlags.BooleanLike) return true;
-	if (type.flags & ts.TypeFlags.StringLike) return true;
-	if (type.flags & ts.TypeFlags.BigIntLike) return true;
+	if (type.flags & ts$1.TypeFlags.NumberLike) return true;
+	if (type.flags & ts$1.TypeFlags.BooleanLike) return true;
+	if (type.flags & ts$1.TypeFlags.StringLike) return true;
+	if (type.flags & ts$1.TypeFlags.BigIntLike) return true;
 	return false;
 }
-
 //#endregion
-export { primitive_valueof_default as default };
+export { primitive_valueof_default as default };

package/dist/rules/slim-try.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/slim-try.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noSafeLine", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/slim-try.mjs

@@ -0,0 +1,150 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/slim-try.ts
+/**
+* @fileoverview
+*
+* This rule warns when the first statement in a `try` block is unlikely to raise any exception.
+*
+* The intention is to reduce the size of `try` blocks that can sometimes be unnecessarily huge.
+*/
+const { name } = path.parse(import.meta.filename);
+var slim_try_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce moving safe statements out of `try` blocks",
+			strict: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noSafeLine: "It looks like this statement can safely be moved before the try block" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { TryStatement(node) {
+			const [stmt] = node.block.body;
+			if (!stmt) return;
+			if (!isSafeStatement(stmt)) return;
+			context.report({
+				node: stmt,
+				messageId: "noSafeLine",
+				*fix(fixer) {
+					const txt = context.sourceCode.getText(stmt);
+					yield fixer.remove(stmt);
+					yield fixer.insertTextBefore(node, `${txt}\n`);
+				}
+			});
+		} };
+	}
+});
+function isSafeStatement(stmt) {
+	const stmtType = stmt.type;
+	switch (stmtType) {
+		case AST_NODE_TYPES.BlockStatement: return stmt.body.every((statement) => isSafeStatement(statement));
+		case AST_NODE_TYPES.BreakStatement:
+		case AST_NODE_TYPES.ClassDeclaration:
+		case AST_NODE_TYPES.ContinueStatement:
+		case AST_NODE_TYPES.DebuggerStatement: return true;
+		case AST_NODE_TYPES.DoWhileStatement: return isSafeStatement(stmt.body);
+		case AST_NODE_TYPES.EmptyStatement: return true;
+		case AST_NODE_TYPES.ExportAllDeclaration:
+		case AST_NODE_TYPES.ExportDefaultDeclaration:
+		case AST_NODE_TYPES.ExportNamedDeclaration: return false;
+		case AST_NODE_TYPES.ExpressionStatement: return isSafeExpression(stmt.expression);
+		case AST_NODE_TYPES.ForInStatement:
+		case AST_NODE_TYPES.ForOfStatement: return isSafeInitialiser(stmt.left) && isSafeExpression(stmt.right) && isSafeStatement(stmt.body);
+		case AST_NODE_TYPES.ForStatement: return isSafeInitialiser(stmt.init) && isSafeInitialiser(stmt.test) && isSafeInitialiser(stmt.update) && isSafeStatement(stmt.body);
+		case AST_NODE_TYPES.FunctionDeclaration: return true;
+		case AST_NODE_TYPES.IfStatement: return isSafeStatement(stmt.consequent) && (!stmt.alternate || isSafeStatement(stmt.alternate));
+		case AST_NODE_TYPES.ImportDeclaration: return false;
+		case AST_NODE_TYPES.LabeledStatement: return isSafeStatement(stmt.body);
+		case AST_NODE_TYPES.ReturnStatement: return !stmt.argument || isSafeExpression(stmt.argument);
+		case AST_NODE_TYPES.SwitchStatement: return isSafeExpression(stmt.discriminant) && stmt.cases.every((c) => (!c.test || isSafeExpression(c.test)) && c.consequent.every((statement) => isSafeStatement(statement)));
+		case AST_NODE_TYPES.ThrowStatement:
+		case AST_NODE_TYPES.TryStatement: return false;
+		case AST_NODE_TYPES.TSDeclareFunction:
+		case AST_NODE_TYPES.TSEnumDeclaration:
+		case AST_NODE_TYPES.TSExportAssignment:
+		case AST_NODE_TYPES.TSImportEqualsDeclaration:
+		case AST_NODE_TYPES.TSInterfaceDeclaration:
+		case AST_NODE_TYPES.TSModuleDeclaration:
+		case AST_NODE_TYPES.TSNamespaceExportDeclaration:
+		case AST_NODE_TYPES.TSTypeAliasDeclaration: return true;
+		case AST_NODE_TYPES.VariableDeclaration: return stmt.declarations.every((decl) => !decl.init || isSafeExpression(decl.id) && isSafeExpression(decl.init));
+		case AST_NODE_TYPES.WhileStatement: return isSafeExpression(stmt.test) && isSafeStatement(stmt.body);
+		case AST_NODE_TYPES.WithStatement: return isSafeExpression(stmt.object) && isSafeStatement(stmt.body);
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected statement type: ${stmtType}`);
+			return false;
+	}
+}
+function isSafeExpression(expr) {
+	const exprType = expr.type;
+	switch (exprType) {
+		case AST_NODE_TYPES.ArrayExpression: return expr.elements.every((elt) => {
+			if (!elt) return true;
+			if (elt.type === AST_NODE_TYPES.SpreadElement) return isSafeExpression(elt.argument);
+			return isSafeExpression(elt);
+		});
+		case AST_NODE_TYPES.ArrayPattern: return expr.elements.every((elt) => !elt || isSafeExpression(elt));
+		case AST_NODE_TYPES.ArrowFunctionExpression: return true;
+		case AST_NODE_TYPES.AssignmentPattern:
+		case AST_NODE_TYPES.AssignmentExpression: return isSafeExpression(expr.right);
+		case AST_NODE_TYPES.AwaitExpression: return false;
+		case AST_NODE_TYPES.BinaryExpression:
+			if (expr.operator === "in" || expr.operator === "instanceof") return false;
+			return isSafeExpression(expr.left) && isSafeExpression(expr.right);
+		case AST_NODE_TYPES.CallExpression: return false;
+		case AST_NODE_TYPES.ChainExpression: return isSafeExpression(expr.expression);
+		case AST_NODE_TYPES.ClassExpression: return true;
+		case AST_NODE_TYPES.ConditionalExpression: return isSafeExpression(expr.test) && isSafeExpression(expr.consequent) && isSafeExpression(expr.alternate);
+		case AST_NODE_TYPES.FunctionExpression:
+		case AST_NODE_TYPES.Identifier: return true;
+		case AST_NODE_TYPES.ImportExpression:
+		case AST_NODE_TYPES.JSXElement:
+		case AST_NODE_TYPES.JSXFragment: return false;
+		case AST_NODE_TYPES.Literal: return true;
+		case AST_NODE_TYPES.LogicalExpression: return isSafeExpression(expr.left) && isSafeExpression(expr.right);
+		case AST_NODE_TYPES.MemberExpression: return false;
+		case AST_NODE_TYPES.MetaProperty: return true;
+		case AST_NODE_TYPES.NewExpression: return false;
+		case AST_NODE_TYPES.ObjectExpression: return expr.properties.every((prop) => {
+			if (prop.type === AST_NODE_TYPES.SpreadElement) return isSafeExpression(prop.argument);
+			return isSafeExpression(prop.key) && isSafeExpression(prop.value);
+		});
+		case AST_NODE_TYPES.ObjectPattern: return expr.properties.every((prop) => isSafeExpression(prop));
+		case AST_NODE_TYPES.Property: return isSafeExpression(expr.key) && isSafeExpression(expr.value);
+		case AST_NODE_TYPES.RestElement: return isSafeExpression(expr.argument);
+		case AST_NODE_TYPES.SequenceExpression: return expr.expressions.every((expression) => isSafeExpression(expression));
+		/* v8 ignore next -- @preserve */
+		case AST_NODE_TYPES.Super:
+		case AST_NODE_TYPES.TaggedTemplateExpression: return false;
+		case AST_NODE_TYPES.TemplateLiteral: return expr.expressions.every((expression) => isSafeExpression(expression));
+		case AST_NODE_TYPES.ThisExpression: return true;
+		case AST_NODE_TYPES.TSAsExpression: return isSafeExpression(expr.expression);
+		/* v8 ignore next -- @preserve */
+		case AST_NODE_TYPES.TSEmptyBodyFunctionExpression:
+		case AST_NODE_TYPES.TSInstantiationExpression: return true;
+		case AST_NODE_TYPES.TSNonNullExpression:
+		case AST_NODE_TYPES.TSSatisfiesExpression:
+		case AST_NODE_TYPES.TSTypeAssertion: return isSafeExpression(expr.expression);
+		case AST_NODE_TYPES.UnaryExpression:
+		case AST_NODE_TYPES.UpdateExpression:
+		case AST_NODE_TYPES.YieldExpression: return !expr.argument || isSafeExpression(expr.argument);
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected expression type: ${exprType}`);
+			return false;
+	}
+}
+function isSafeInitialiser(initialiser) {
+	if (!initialiser) return true;
+	if (initialiser.type === AST_NODE_TYPES.VariableDeclaration) return isSafeStatement(initialiser);
+	return isSafeExpression(initialiser);
+}
+//#endregion
+export { slim_try_default as default };

package/dist/rules/styled-button-has-type.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { TSESLint } from "@typescript-eslint/utils";
+
+//#region lib/rules/styled-button-has-type.d.ts
+declare const _default: TSESLint.RuleModule<"missingType" | "complexType" | "invalidValue", [], WyrmPluginDocs, TSESLint.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/styled-button-has-type.mjs

@@ -0,0 +1,82 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { ASTUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/styled-button-has-type.ts
+/**
+* @fileoverview
+*
+* This will only work if the styled component is declared in the same file where it is used.
+*/
+const { name } = path.parse(import.meta.filename);
+var styled_button_has_type_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow usage of `styled.button` without an explicit `type` attribute.",
+			recommended: true
+		},
+		schema: [],
+		messages: {
+			missingType: "Missing an explicit type attribute for button",
+			complexType: "The button type attribute must be specified by a static string",
+			invalidValue: "\"{{value}}\" is an invalid value for button type attribute"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { JSXElement(node) {
+			if (node.openingElement.name.type !== AST_NODE_TYPES.JSXIdentifier) return;
+			const def = findDef(context.sourceCode.getScope(node), node.openingElement.name.name);
+			if (!def) return;
+			if (def.node.type !== AST_NODE_TYPES.VariableDeclarator) return;
+			const { init } = def.node;
+			if (!init) return;
+			if (!isStyledHtmlButton(init)) return;
+			const found = node.openingElement.attributes.filter((attr) => attr.type === AST_NODE_TYPES.JSXAttribute).find((attr) => attr.name.name === "type");
+			if (!found) {
+				context.report({
+					node,
+					messageId: "missingType"
+				});
+				return;
+			}
+			if (found.value?.type !== AST_NODE_TYPES.Literal || typeof found.value.value !== "string") {
+				context.report({
+					node,
+					messageId: "complexType"
+				});
+				return;
+			}
+			if ([
+				"button",
+				"submit",
+				"reset"
+			].includes(found.value.value)) return;
+			context.report({
+				node,
+				messageId: "invalidValue",
+				data: { value: found.value.value }
+			});
+		} };
+	}
+});
+function findDef(scope, ident) {
+	return ASTUtils.findVariable(scope, ident)?.defs.at(-1);
+}
+function isStyledHtmlButton(expr) {
+	if (expr.type !== AST_NODE_TYPES.TaggedTemplateExpression) return false;
+	return isStyledHtmlElement(expr.tag, "button");
+}
+function isStyledHtmlElement(expr, htmlTag) {
+	if (expr.type === AST_NODE_TYPES.MemberExpression) return expr.object.type === AST_NODE_TYPES.Identifier && expr.object.name === "styled" && expr.property.type === AST_NODE_TYPES.Identifier && expr.property.name === htmlTag;
+	if (expr.type !== AST_NODE_TYPES.CallExpression) return false;
+	const [arg] = expr.arguments;
+	if (!arg) return false;
+	if (arg.type !== AST_NODE_TYPES.Literal) return false;
+	if (arg.value !== htmlTag) return false;
+	if (expr.callee.type !== AST_NODE_TYPES.Identifier) return false;
+	return expr.callee.name === "styled";
+}
+//#endregion
+export { styled_button_has_type_default as default };