eslint-plugin-wyrm 0.0.10 → 0.0.13

package/dist/rules/no-if-length-for.mjs

@@ -0,0 +1,91 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Option, Some, getFirstOption } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/no-if-length-for.ts
+const { name } = path.parse(import.meta.filename);
+var no_if_length_for_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid redundant condition for positive length before a loop",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noIfLengthFor: "You don't need to check that an array is not empty before a for loop" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			if (node.alternate) return;
+			const maybeIdent = getArrayIdent(node.test);
+			if (!maybeIdent.some) return;
+			const ident = maybeIdent.value;
+			const maybeStmt = getUniqueStatement(node.consequent);
+			if (!maybeStmt.some) return;
+			const stmt = maybeStmt.value;
+			if (!matchLoopWithIdent(stmt, ident)) return;
+			context.report({
+				node,
+				messageId: "noIfLengthFor",
+				fix(fixer) {
+					const text = context.sourceCode.getText(stmt);
+					return fixer.replaceText(node, text);
+				}
+			});
+		} };
+	}
+});
+function matchLoopWithIdent(stmt, ident) {
+	return matchForLoopWithIdent(stmt, ident) || matchForEachLoopWithIdent(stmt, ident);
+}
+function matchForLoopWithIdent(stmt, ident) {
+	if (stmt.type !== AST_NODE_TYPES.ForOfStatement) return false;
+	if (stmt.right.type !== AST_NODE_TYPES.Identifier) return false;
+	if (stmt.right.name !== ident) return false;
+	return true;
+}
+function matchForEachLoopWithIdent(stmt, ident) {
+	if (stmt.type !== AST_NODE_TYPES.ExpressionStatement) return false;
+	if (stmt.expression.type !== AST_NODE_TYPES.CallExpression) return false;
+	if (stmt.expression.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (stmt.expression.callee.property.type !== AST_NODE_TYPES.Identifier) return false;
+	if (stmt.expression.callee.property.name !== "forEach") return false;
+	if (stmt.expression.callee.object.type !== AST_NODE_TYPES.Identifier) return false;
+	if (stmt.expression.callee.object.name !== ident) return false;
+	return true;
+}
+function getArrayIdent(test) {
+	return getFirstOption([extractIdentFromLengthAccess(test), extractIdentFromPositiveLengthCheck(test)]);
+}
+function extractIdentFromLengthAccess(test) {
+	if (test.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (test.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (test.property.name !== "length") return None;
+	if (test.object.type !== AST_NODE_TYPES.Identifier) return None;
+	return Some(test.object.name);
+}
+function extractIdentFromPositiveLengthCheck(test) {
+	if (test.type !== AST_NODE_TYPES.BinaryExpression) return None;
+	switch (test.operator) {
+		case "!=":
+		case "!==": return getFirstOption([extractIdentFromLengthComparison(test.left, test.right), extractIdentFromLengthComparison(test.right, test.left)]);
+		case ">": return extractIdentFromLengthComparison(test.left, test.right);
+		case "<": return extractIdentFromLengthComparison(test.right, test.left);
+		default: return None;
+	}
+}
+function extractIdentFromLengthComparison(left, right) {
+	if (right.type !== AST_NODE_TYPES.Literal) return None;
+	if (right.value !== 0) return None;
+	return extractIdentFromLengthAccess(left);
+}
+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 { no_if_length_for_default as default };

package/dist/rules/no-inline-jsdoc-tag.d.mts

@@ -1,10 +1,10 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint39 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-inline-jsdoc-tag.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint39.RuleModule<"noInlineJsDocTags", [{
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noInlineJsDocTags", [{
   tags: string[];
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint39.RuleListener> & {
+}], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-inline-jsdoc-tag.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_TOKEN_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/no-inline-jsdoc-tag.ts
 const { name } = path.parse(import.meta.filename);
 const DEFAULT_ADDITIONAL_JSDOC_TAGS = [];
@@ -150,6 +149,5 @@ function getJsDocTags() {
 		"yields"
 	];
 }
-
 //#endregion
-export { no_inline_jsdoc_tag_default as default };
+export { no_inline_jsdoc_tag_default as default };

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

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint41 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-invalid-date-literal.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint41.RuleModule<"noInvalidDateLiteral", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint41.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noInvalidDateLiteral", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

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

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/no-invalid-date-literal.ts
 const { name } = path.parse(import.meta.filename);
 var no_invalid_date_literal_default = createRule({
@@ -17,6 +16,45 @@ var no_invalid_date_literal_default = createRule({
 	},
 	defaultOptions: [],
 	create(context) {
+		function checkDateParse(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (callee.object.type !== AST_NODE_TYPES.Identifier) return;
+			if (callee.property.type !== AST_NODE_TYPES.Identifier) return;
+			if (callee.object.name !== "Date") return;
+			if (callee.property.name !== "parse") return;
+			const [arg] = node.arguments;
+			if (!arg) return;
+			if (arg.type !== AST_NODE_TYPES.Literal) return;
+			if (typeof arg.value === "string") {
+				if (isValidDateLiteral(arg.value)) return;
+				context.report({
+					node,
+					messageId: "noInvalidDateLiteral"
+				});
+			}
+		}
+		function checkPlainDateFrom(node) {
+			const { callee } = node;
+			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (callee.object.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (callee.property.type !== AST_NODE_TYPES.Identifier) return;
+			if (callee.object.object.type !== AST_NODE_TYPES.Identifier) return;
+			if (callee.object.property.type !== AST_NODE_TYPES.Identifier) return;
+			if (callee.object.object.name !== "Temporal") return;
+			if (callee.object.property.name !== "PlainDate") return;
+			if (callee.property.name !== "from") return;
+			const [arg] = node.arguments;
+			if (!arg) return;
+			if (arg.type !== AST_NODE_TYPES.Literal) return;
+			if (typeof arg.value === "string") {
+				if (isValidDateLiteral(arg.value)) return;
+				context.report({
+					node,
+					messageId: "noInvalidDateLiteral"
+				});
+			}
+		}
 		return {
 			NewExpression(node) {
 				if (node.callee.type !== AST_NODE_TYPES.Identifier) return;
@@ -41,22 +79,8 @@ var no_invalid_date_literal_default = createRule({
 				}
 			},
 			CallExpression(node) {
-				const { callee } = node;
-				if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-				if (callee.object.type !== AST_NODE_TYPES.Identifier) return;
-				if (callee.property.type !== AST_NODE_TYPES.Identifier) return;
-				if (callee.object.name !== "Date") return;
-				if (callee.property.name !== "parse") return;
-				const [arg] = node.arguments;
-				if (!arg) return;
-				if (arg.type !== AST_NODE_TYPES.Literal) return;
-				if (typeof arg.value === "string") {
-					if (isValidDateLiteral(arg.value)) return;
-					context.report({
-						node,
-						messageId: "noInvalidDateLiteral"
-					});
-				}
+				checkDateParse(node);
+				checkPlainDateFrom(node);
 			}
 		};
 	}
@@ -65,6 +89,5 @@ function isValidDateLiteral(literal) {
 	const value = new Date(literal).valueOf();
 	return !Number.isNaN(value);
 }
-
 //#endregion
-export { no_invalid_date_literal_default as default };
+export { no_invalid_date_literal_default as default };

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

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

package/dist/rules/no-jsx-statement.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/no-jsx-statement.ts
 const { name } = path.parse(import.meta.filename);
 var no_jsx_statement_default = createRule({
@@ -26,6 +25,5 @@ var no_jsx_statement_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { no_jsx_statement_default as default };
+export { no_jsx_statement_default as default };

package/dist/rules/no-lax-array-type.d.mts

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

package/dist/rules/no-lax-array-type.mjs

@@ -0,0 +1,129 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { ASTUtils, AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import * as ts$1 from "typescript";
+//#region lib/rules/no-lax-array-type.ts
+const { name } = path.parse(import.meta.filename);
+var no_lax_array_type_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid declaring array types that are wider than the types of the actual elements",
+			requiresTypeChecking: true,
+			strict: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			noLaxArrayType: "This type is never used for any element, maybe you can remove it from the array type: {{unusedType}}",
+			removeType: "Remove {{unusedType}}"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		let checker;
+		function getChecker() {
+			checker ??= getServices().program.getTypeChecker();
+			return checker;
+		}
+		return { VariableDeclarator(node) {
+			const { id } = node;
+			if (id.type !== AST_NODE_TYPES.Identifier) return;
+			if (node.parent.kind !== "const") return;
+			if (!id.typeAnnotation?.typeAnnotation) return;
+			if (node.init?.type !== AST_NODE_TYPES.ArrayExpression) return;
+			const scope = context.sourceCode.getScope(id);
+			const variable = ASTUtils.findVariable(scope, id);
+			/* v8 ignore next -- @preserve */
+			if (!variable) return;
+			if (variable.references.filter((ref) => isPossiblyMutatingReference(ref, id)).length > 1) return;
+			const estreeArrayTypeNode = id.typeAnnotation.typeAnnotation;
+			const tsArrayTypeNode = getServices().esTreeNodeToTSNodeMap.get(estreeArrayTypeNode);
+			const inferredElementTypes = inferAllElementTypes(node.init);
+			if (!inferredElementTypes.length) return;
+			const arrayElementsTypeNodes = getArrayElementsTypeNodes(tsArrayTypeNode);
+			for (const arrayTypeNode of arrayElementsTypeNodes) {
+				const arrayType = getChecker().getTypeFromTypeNode(arrayTypeNode);
+				if (inferredElementTypes.some((inferredElementType) => isAssignableTo(inferredElementType, arrayType))) continue;
+				const estreeNode = getServices().tsNodeToESTreeNodeMap.get(arrayTypeNode);
+				const typeAsString = arrayTypeNode.getText();
+				context.report({
+					node,
+					messageId: "noLaxArrayType",
+					data: { unusedType: typeAsString },
+					suggest: [{
+						messageId: "removeType",
+						data: { unusedType: typeAsString },
+						*fix(fixer) {
+							if (estreeNode.parent?.type === AST_NODE_TYPES.TSUnionType && estreeNode.parent.types[0] === estreeNode) {
+								const nextToken = context.sourceCode.getTokenAfter(estreeNode);
+								yield fixer.remove(estreeNode);
+								/* v8 ignore else -- @preserve */
+								if (nextToken) yield fixer.remove(nextToken);
+								return;
+							}
+							const previousToken = context.sourceCode.getTokenBefore(estreeNode);
+							yield fixer.remove(estreeNode);
+							/* v8 ignore else -- @preserve */
+							if (previousToken) yield fixer.remove(previousToken);
+						}
+					}]
+				});
+			}
+		} };
+		function inferAllElementTypes(array) {
+			return array.elements.map((elt) => {
+				if (!elt) return getChecker().getUndefinedType();
+				return getServices().getTypeAtLocation(elt);
+			});
+		}
+		function isAssignableTo(source, target) {
+			if (source.isUnion()) return source.types.some((t) => isAssignableTo(t, target));
+			return getChecker().isTypeAssignableTo(source, getChecker().getWidenedType(target));
+		}
+	}
+});
+function getArrayElementsTypeNodes(arrayTypeNode) {
+	const innerTypeNode = getArrayTypeNode(arrayTypeNode);
+	if (!innerTypeNode) return [];
+	return getUnionTypeNodes(innerTypeNode);
+}
+function getUnionTypeNodes(type) {
+	if (ts$1.isParenthesizedTypeNode(type)) return getUnionTypeNodes(type.type);
+	if (ts$1.isUnionTypeNode(type)) return [...type.types];
+	return [];
+}
+/** Extract the inner type node from an Array type node */
+function getArrayTypeNode(arrayTypeNode) {
+	if (ts$1.isArrayTypeNode(arrayTypeNode)) return arrayTypeNode.elementType;
+	if (!ts$1.isTypeReferenceNode(arrayTypeNode)) return null;
+	if (!ts$1.isIdentifier(arrayTypeNode.typeName)) return null;
+	if (arrayTypeNode.typeName.escapedText.toString() !== "Array") return null;
+	const [typeArgNode] = arrayTypeNode.typeArguments ?? [];
+	if (!typeArgNode) return null;
+	return typeArgNode;
+}
+function isPossiblyMutatingReference(ref, id) {
+	if (ref.isWrite()) return true;
+	if (ref.identifier.parent.type !== AST_NODE_TYPES.MemberExpression || ref.identifier.parent.parent.type !== AST_NODE_TYPES.CallExpression || ref.identifier.parent.object.type !== AST_NODE_TYPES.Identifier || ref.identifier.parent.property.type !== AST_NODE_TYPES.Identifier || ref.identifier.parent.object.name !== id.name) return false;
+	if (ref.identifier.parent.property.name === "includes") return true;
+	return [
+		"copyWithin",
+		"fill",
+		"pop",
+		"push",
+		"reverse",
+		"shift",
+		"sort",
+		"splice",
+		"unshift"
+	].includes(ref.identifier.parent.property.name);
+}
+//#endregion
+export { no_lax_array_type_default as default };

package/dist/rules/no-lax-return-type.d.mts

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

package/dist/rules/no-lax-return-type.mjs

@@ -0,0 +1,138 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import * as ts$1 from "typescript";
+//#region lib/rules/no-lax-return-type.ts
+const { name } = path.parse(import.meta.filename);
+var no_lax_return_type_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid declaring function return types that are wider than the types of the actual return values",
+			requiresTypeChecking: true,
+			strict: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			noLaxReturnType: "This type is never returned from the function, maybe you can remove it from the return type: {{unusedType}}",
+			removeType: "Remove {{unusedType}}"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		let checker;
+		function getChecker() {
+			checker ??= getServices().program.getTypeChecker();
+			return checker;
+		}
+		return {
+			ArrowFunctionExpression: checkFunction,
+			FunctionExpression: checkFunction,
+			FunctionDeclaration: checkFunction
+		};
+		function inferAllReturnTypes(body, async) {
+			if (body.type !== AST_NODE_TYPES.BlockStatement) return [getServices().getTypeAtLocation(body)];
+			return getAllReturnStatements(body).map((stmt) => {
+				if (!stmt.argument) return getChecker().getVoidType();
+				const type = getServices().getTypeAtLocation(stmt.argument);
+				if (!async) return type;
+				return getChecker().getAwaitedType(type) ?? type;
+			});
+		}
+		function isAssignableTo(source, target) {
+			if (source.isUnion()) return source.types.some((t) => isAssignableTo(t, target));
+			return getChecker().isTypeAssignableTo(source, getChecker().getWidenedType(target));
+		}
+		function checkReturnTypeNode(returnTypeNode, inferredReturnTypes) {
+			const returnType = getChecker().getTypeFromTypeNode(returnTypeNode);
+			if (returnType.flags & ts$1.TypeFlags.Conditional) return;
+			if (inferredReturnTypes.some((inferredReturnType) => isAssignableTo(inferredReturnType, returnType))) return;
+			const estreeNode = getServices().tsNodeToESTreeNodeMap.get(returnTypeNode);
+			const typeAsString = returnTypeNode.getText();
+			context.report({
+				node: estreeNode,
+				messageId: "noLaxReturnType",
+				data: { unusedType: typeAsString },
+				suggest: [{
+					messageId: "removeType",
+					data: { unusedType: typeAsString },
+					*fix(fixer) {
+						if (estreeNode.parent?.type === AST_NODE_TYPES.TSUnionType && estreeNode.parent.types[0] === estreeNode) {
+							const nextToken = context.sourceCode.getTokenAfter(estreeNode);
+							yield fixer.remove(estreeNode);
+							/* v8 ignore else -- @preserve */
+							if (nextToken) yield fixer.remove(nextToken);
+							return;
+						}
+						const previousToken = context.sourceCode.getTokenBefore(estreeNode);
+						yield fixer.remove(estreeNode);
+						/* v8 ignore else -- @preserve */
+						if (previousToken) yield fixer.remove(previousToken);
+					}
+				}]
+			});
+		}
+		function checkFunction(node) {
+			if (!node.returnType) return;
+			if (node.generator) return;
+			if (node.parent.type === AST_NODE_TYPES.MethodDefinition) return;
+			const inferredReturnTypes = inferAllReturnTypes(node.body, node.async);
+			if (!inferredReturnTypes.length) return;
+			const sigs = getServices().getTypeAtLocation(node).getCallSignatures();
+			if (sigs.length > 1 && node.typeParameters) return;
+			for (const sig of sigs) {
+				const returnTypes = getUnionTypeNodes(sig.getDeclaration().type, node.async);
+				for (const returnTypeNode of returnTypes) checkReturnTypeNode(returnTypeNode, inferredReturnTypes);
+			}
+		}
+	}
+});
+function getUnionTypeNodes(type, async) {
+	/* v8 ignore if -- @preserve */
+	if (!type) return [];
+	if (async) {
+		const promiseTypeNode = getPromiseTypeNode(type);
+		if (!promiseTypeNode) return [];
+		return getUnionTypeNodes(promiseTypeNode, false);
+	}
+	if (ts$1.isUnionTypeNode(type)) return [...type.types];
+	return [type];
+}
+function getAllReturnStatements(stmt) {
+	if (stmt == null) return [];
+	switch (stmt.type) {
+		case AST_NODE_TYPES.ReturnStatement: return [stmt];
+		case AST_NODE_TYPES.BlockStatement: return stmt.body.flatMap((s) => getAllReturnStatements(s));
+		case AST_NODE_TYPES.IfStatement: return [...getAllReturnStatements(stmt.consequent), ...getAllReturnStatements(stmt.alternate)];
+		case AST_NODE_TYPES.SwitchStatement: return stmt.cases.flatMap((c) => c.consequent).flatMap((c) => getAllReturnStatements(c));
+		case AST_NODE_TYPES.ForInStatement:
+		case AST_NODE_TYPES.ForOfStatement:
+		case AST_NODE_TYPES.ForStatement:
+		case AST_NODE_TYPES.WhileStatement:
+		case AST_NODE_TYPES.DoWhileStatement: return getAllReturnStatements(stmt.body);
+		case AST_NODE_TYPES.TryStatement: return [
+			...getAllReturnStatements(stmt.block),
+			...getAllReturnStatements(stmt.handler?.body),
+			...getAllReturnStatements(stmt.finalizer)
+		];
+		default: return [];
+	}
+}
+/** Extract the inner type node from a Promise type node */
+function getPromiseTypeNode(returnTypeNode) {
+	if (!ts$1.isTypeReferenceNode(returnTypeNode)) return null;
+	if (!ts$1.isIdentifier(returnTypeNode.typeName)) return null;
+	if (returnTypeNode.typeName.escapedText.toString() !== "Promise") return null;
+	const [typeArgNode] = returnTypeNode.typeArguments ?? [];
+	if (!typeArgNode) return null;
+	return typeArgNode;
+}
+//#endregion
+export { no_lax_return_type_default as default };

package/dist/rules/no-mutable-literal-fill.d.mts

@@ -1,9 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint45 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-mutable-literal-fill.d.ts
-
-declare const _default: _typescript_eslint_utils_ts_eslint45.RuleModule<"noMutableLiteralFill", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint45.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noMutableLiteralFill", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-mutable-literal-fill.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/no-mutable-literal-fill.ts
 /**
 * @fileoverview
@@ -61,6 +60,5 @@ function isMutableLiteral(expr) {
 		default: return false;
 	}
 }
-
 //#endregion
-export { no_mutable_literal_fill_default as default };
+export { no_mutable_literal_fill_default as default };

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