eslint-plugin-wyrm 0.0.10 → 0.0.13

package/dist/rules/named-export-with-side-effects.mjs

@@ -0,0 +1,72 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/named-export-with-side-effects.ts
+const { name } = path.parse(import.meta.filename);
+const DEFAULT_STRICT = false;
+var named_export_with_side_effects_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid named exports in files with side effects",
+			recommended: true
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { strict: {
+				type: "boolean",
+				description: `Whether to consider call expressions as possible side effects. Default: \`${DEFAULT_STRICT}\``
+			} }
+		}],
+		messages: { namedExportWithSideEffects: "When exports from this file are imported, this might also be executed. Make sure this is expected." }
+	},
+	defaultOptions: [{ strict: DEFAULT_STRICT }],
+	create(context, [options]) {
+		return { Program(node) {
+			let hasNamedExports = false;
+			const sideEffects = [];
+			for (const stmt of node.body) {
+				if (stmt.type === AST_NODE_TYPES.ExportNamedDeclaration) {
+					hasNamedExports = true;
+					continue;
+				}
+				if (isSideEffect(stmt, options.strict)) sideEffects.push(stmt);
+			}
+			if (!hasNamedExports) return;
+			for (const sideEffect of sideEffects) context.report({
+				node: sideEffect,
+				messageId: "namedExportWithSideEffects"
+			});
+		} };
+	}
+});
+function isSideEffect(stmt, strict) {
+	switch (stmt.type) {
+		case AST_NODE_TYPES.BreakStatement:
+		case AST_NODE_TYPES.ContinueStatement:
+		case AST_NODE_TYPES.DebuggerStatement:
+		case AST_NODE_TYPES.DoWhileStatement:
+		case AST_NODE_TYPES.SwitchStatement:
+		case AST_NODE_TYPES.ForStatement:
+		case AST_NODE_TYPES.ForInStatement:
+		case AST_NODE_TYPES.ForOfStatement:
+		case AST_NODE_TYPES.ThrowStatement:
+		case AST_NODE_TYPES.TryStatement:
+		case AST_NODE_TYPES.WhileStatement: return true;
+		case AST_NODE_TYPES.BlockStatement: return stmt.body.some((s) => isSideEffect(s, strict));
+		case AST_NODE_TYPES.IfStatement:
+			if (stmt.alternate && isSideEffect(stmt.alternate, strict)) return true;
+			return isSideEffect(stmt.consequent, strict);
+		case AST_NODE_TYPES.ExpressionStatement: switch (stmt.expression.type) {
+			case AST_NODE_TYPES.AwaitExpression:
+			case AST_NODE_TYPES.UpdateExpression: return true;
+			case AST_NODE_TYPES.CallExpression: return strict;
+			default: return false;
+		}
+		default: return false;
+	}
+}
+//#endregion
+export { named_export_with_side_effects_default as default };

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

package/dist/rules/nested-reduce.mjs

@@ -0,0 +1,46 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/nested-reduce.ts
+const { name } = path.parse(import.meta.filename);
+var nested_reduce_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid nested `reduce` calls",
+			strict: true
+		},
+		schema: [],
+		messages: { noNestedReduce: "Refactor to avoid nesting `reduce` calls." }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { CallExpression(node) {
+			if (!isReduceCall(node)) return;
+			if (!isInsideReduceCall(node)) return;
+			context.report({
+				node: node.callee,
+				messageId: "noNestedReduce"
+			});
+		} };
+	}
+});
+function isReduceCall(expr) {
+	if (expr.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (expr.callee.property.type !== AST_NODE_TYPES.Identifier) return false;
+	return expr.callee.property.name === "reduce";
+}
+function isInsideReduceCall(node) {
+	if (!node.parent) return false;
+	switch (node.parent.type) {
+		case AST_NODE_TYPES.FunctionDeclaration: return false;
+		case AST_NODE_TYPES.CallExpression:
+			if (isReduceCall(node.parent)) return true;
+			break;
+		default: break;
+	}
+	return isInsideReduceCall(node.parent);
+}
+//#endregion
+export { nested_reduce_default as default };

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

package/dist/rules/nested-try-catch.mjs

@@ -0,0 +1,37 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/nested-try-catch.ts
+const { name } = path.parse(import.meta.filename);
+var nested_try_catch_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid nested try/catch statements",
+			strict: true
+		},
+		schema: [],
+		messages: { noNestedTryCatch: "Refactor to avoid nesting try/catch statements." }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { TryStatement(node) {
+			if (node.parent.type !== AST_NODE_TYPES.BlockStatement) return;
+			switch (node.parent.parent.type) {
+				case AST_NODE_TYPES.TryStatement:
+				case AST_NODE_TYPES.CatchClause: {
+					const token = context.sourceCode.getFirstToken(node);
+					context.report({
+						node: token ?? node,
+						messageId: "noNestedTryCatch"
+					});
+					break;
+				}
+				default: break;
+			}
+		} };
+	}
+});
+//#endregion
+export { nested_try_catch_default as default };

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

package/dist/rules/no-commented-out-comment.mjs

@@ -0,0 +1,31 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+//#region lib/rules/no-commented-out-comment.ts
+const { name } = path.parse(import.meta.filename);
+var no_commented_out_comment_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid commented out comments",
+			recommended: true
+		},
+		schema: [],
+		messages: { commentedOutComment: "This looks like a commented out comment. Make sure this is expected." }
+	},
+	defaultOptions: [],
+	create(context) {
+		if (typeof context.sourceCode.getAllComments === "undefined") return {};
+		const comments = context.sourceCode.getAllComments();
+		for (const comment of comments) checkComment(comment);
+		return {};
+		function checkComment(comment) {
+			if (comment.value.trim().startsWith("//") || comment.value.trim().startsWith("/*")) context.report({
+				node: comment,
+				messageId: "commentedOutComment"
+			});
+		}
+	}
+});
+//#endregion
+export { no_commented_out_comment_default as default };

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

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

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

@@ -1,8 +1,7 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
-import { ASTUtils, AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-
+import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
+import * as ts$1 from "typescript";
 //#region lib/rules/no-constant-template-expression.ts
 /**
 * @fileoverview
@@ -55,6 +54,8 @@ var no_constant_template_expression_default = createRule({
 					if (references.length > 2) return;
 					const def = defs.at(-1);
 					if (def?.parent?.type === AST_NODE_TYPES.VariableDeclaration && def.parent.parent.type === AST_NODE_TYPES.ExportNamedDeclaration) return;
+					if (def?.type !== TSESLint.Scope.DefinitionType.Variable) return;
+					if (isNonAlphabeticStringLiteral(def.node)) return;
 				}
 			}
 			const services = ESLintUtils.getParserServices(context);
@@ -63,7 +64,7 @@ var no_constant_template_expression_default = createRule({
 			if (value === null) return;
 			if (value.length >= options.minAllowedLength) return;
 			const sym = services.getSymbolAtLocation(expr);
-			if (sym && sym.getFlags() & ts.SymbolFlags.EnumMember && !quasis.some((quasi) => quasi.value.cooked)) return;
+			if (sym && sym.getFlags() & ts$1.SymbolFlags.EnumMember && !quasis.some((quasi) => quasi.value.cooked)) return;
 			context.report({
 				node: expr,
 				messageId: "noConstantTemplateExpression",
@@ -77,7 +78,7 @@ var no_constant_template_expression_default = createRule({
 						const nextQuasi = quasis.find((quasi) => quasi.range[0] >= identEnd);
 						/* v8 ignore if -- @preserve */
 						if (!previousQuasi || !nextQuasi) {
-							console.error("No previous/next quasi found. This should never happen.");
+							console.error("[wyrm] No previous/next quasi found. This should never happen.");
 							return;
 						}
 						const start = previousQuasi.range[1];
@@ -90,7 +91,8 @@ var no_constant_template_expression_default = createRule({
 		}
 		return { TemplateLiteral(node) {
 			const { expressions, quasis } = node;
-			if (quasis.some((quasi) => quasi.value.cooked.includes(" "))) return;
+			if (quasis.some((quasi) => quasi.value.cooked?.includes(" "))) return;
+			if (node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) return;
 			const scope = context.sourceCode.getScope(node);
 			for (const expr of expressions) checkExpression(expr, quasis, scope);
 		} };
@@ -98,11 +100,12 @@ var no_constant_template_expression_default = createRule({
 });
 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;
 }
-
+function isNonAlphabeticStringLiteral(node) {
+	return node.init?.type === AST_NODE_TYPES.Literal && typeof node.init.value === "string" && /[^a-zA-Z]/u.test(node.init.value);
+}
 //#endregion
-export { no_constant_template_expression_default as default };
+export { no_constant_template_expression_default as default };

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

package/dist/rules/no-constructed-error-cause.mjs

@@ -0,0 +1,75 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/no-constructed-error-cause.ts
+/**
+* @fileoverview
+*
+* The `Error.cause` property is used to wrap a previously caught error in a new instantiated error:
+*
+* ```ts
+* try {
+*   // ...
+* } catch (err) {
+*   throw Error('New error message', { cause: err });
+* }
+* ```
+*
+* But sometimes it can also be used as a way to store additional information on `Error` objects:
+*
+* ```ts
+* throw Error('Division by zero', { cause: { code: 'division_by_zero' } });
+* ```
+*
+* This second pattern is what this rule forbids. Custom errors should be used instead:
+*
+* ```ts
+* class ZeroDivisionError extends Error {
+*   public override message = 'Division by zero';
+*   public code = 'division_by_zero';
+* }
+*
+* throw new ZeroDivisionError();
+* ```
+*/
+const { name } = path.parse(import.meta.filename);
+var no_constructed_error_cause_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid using `Error.cause` with constructed objects",
+			strict: true
+		},
+		schema: [],
+		messages: { noConstructedErrorCause: "Error.cause should be used to wrap a caught error, not to include new information" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			NewExpression: checkInstantiation,
+			CallExpression: checkInstantiation
+		};
+		function checkInstantiation(node) {
+			if (node.callee.type !== AST_NODE_TYPES.Identifier) return;
+			if (node.callee.name !== "Error") return;
+			const [, options] = node.arguments;
+			if (!options) return;
+			if (options.type !== AST_NODE_TYPES.ObjectExpression) return;
+			const cause = options.properties.filter((prop) => prop.type === AST_NODE_TYPES.Property).find(({ key }) => key.type === AST_NODE_TYPES.Identifier && key.name === "cause")?.value;
+			if (!cause) return;
+			switch (cause.type) {
+				case AST_NODE_TYPES.CallExpression:
+				case AST_NODE_TYPES.ObjectExpression:
+				case AST_NODE_TYPES.NewExpression: break;
+				default: return;
+			}
+			context.report({
+				node,
+				messageId: "noConstructedErrorCause"
+			});
+		}
+	}
+});
+//#endregion
+export { no_constructed_error_cause_default as default };

package/dist/rules/no-convoluted-boolean-expressions.d.mts

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

package/dist/rules/no-convoluted-boolean-expressions.mjs

@@ -0,0 +1,130 @@
+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";
+import * as ts$1 from "typescript";
+//#region lib/rules/no-convoluted-boolean-expressions.ts
+const { name } = path.parse(import.meta.filename);
+var no_convoluted_boolean_expressions_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid simplifiable logical expressions with boolean types",
+			recommended: true,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noConvolutedLogicalExpression: "This logical expression can be simplified" }
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		return { LogicalExpression(node) {
+			if (node.operator === "&&") {
+				const maybeXor = getFirstOption([getConvolutedXor(node, node.left, node.right), getConvolutedXor(node, node.right, node.left)]);
+				if (!maybeXor.some) return;
+				const [a, b] = maybeXor.value;
+				if (!(getServices().getTypeAtLocation(a).flags & ts$1.TypeFlags.BooleanLike)) return;
+				if (!(getServices().getTypeAtLocation(b).flags & ts$1.TypeFlags.BooleanLike)) return;
+				context.report({
+					node,
+					messageId: "noConvolutedLogicalExpression",
+					fix(fixer) {
+						return fixer.replaceText(node, `${a.name} !== ${b.name}`);
+					}
+				});
+				return;
+			}
+			if (node.operator === "||") {
+				const maybeOr = getFirstOption([getConvolutedOr(node, node.left, node.right), getConvolutedOr(node, node.right, node.left)]);
+				if (!maybeOr.some) return;
+				const [a, b] = maybeOr.value;
+				if (!(getServices().getTypeAtLocation(a).flags & ts$1.TypeFlags.BooleanLike)) return;
+				if (!(getServices().getTypeAtLocation(b).flags & ts$1.TypeFlags.BooleanLike)) return;
+				context.report({
+					node,
+					messageId: "noConvolutedLogicalExpression",
+					fix(fixer) {
+						return fixer.replaceText(node, `${a.name} || ${b.name}`);
+					}
+				});
+			}
+		} };
+	}
+});
+function getConvolutedXor(expr, left, right) {
+	if (expr.operator !== "&&") return None;
+	const maybeOr = getOr(left);
+	const maybeNand = getNand(right);
+	if (!maybeOr.some) return None;
+	if (!maybeNand.some) return None;
+	const [maybeOrA, maybeOrB] = maybeOr.value;
+	const [maybeNandA, maybeNandB] = maybeNand.value;
+	if (maybeOrA.name === maybeNandA.name && maybeOrB.name === maybeNandB.name) return Some([maybeOrA, maybeOrB]);
+	if (maybeOrA.name === maybeNandB.name && maybeOrB.name === maybeNandA.name) return Some([maybeOrA, maybeOrB]);
+	return None;
+}
+function getOr(expr) {
+	if (expr.type !== AST_NODE_TYPES.LogicalExpression) return None;
+	if (expr.operator !== "||") return None;
+	if (expr.left.type !== AST_NODE_TYPES.Identifier) return None;
+	if (expr.right.type !== AST_NODE_TYPES.Identifier) return None;
+	return Some([expr.left, expr.right]);
+}
+function getNand(expr) {
+	if (expr.type === AST_NODE_TYPES.UnaryExpression) {
+		if (expr.operator !== "!") return None;
+		return getAnd(expr.argument);
+	}
+	if (expr.type === AST_NODE_TYPES.LogicalExpression) return getFirstOption([getOrNot(expr, expr.left, expr.right), getOrNot(expr, expr.right, expr.left)]);
+	return None;
+}
+function getOrNot(expr, left, right) {
+	if (expr.operator !== "||") return None;
+	const maybeNotA = getNot(left);
+	const maybeNotB = getNot(right);
+	if (!maybeNotA.some) return None;
+	if (!maybeNotB.some) return None;
+	if (maybeNotA.value.type !== AST_NODE_TYPES.Identifier) return None;
+	if (maybeNotB.value.type !== AST_NODE_TYPES.Identifier) return None;
+	return Some([maybeNotA.value, maybeNotB.value]);
+}
+function getAnd(expr) {
+	if (expr.type !== AST_NODE_TYPES.LogicalExpression) return None;
+	if (expr.operator !== "&&") return None;
+	if (expr.left.type !== AST_NODE_TYPES.Identifier) return None;
+	if (expr.right.type !== AST_NODE_TYPES.Identifier) return None;
+	return Some([expr.left, expr.right]);
+}
+function getNot(expr) {
+	if (expr.type !== AST_NODE_TYPES.UnaryExpression) return None;
+	if (expr.operator !== "!") return None;
+	return Some(expr.argument);
+}
+function getConvolutedOr(expr, left, right) {
+	if (expr.operator !== "||") return None;
+	const maybeIneq = getIneq(left);
+	const maybeAnd = getAnd(right);
+	if (!maybeIneq.some) return None;
+	if (!maybeAnd.some) return None;
+	const [maybeIneqA, maybeIneqB] = maybeIneq.value;
+	const [maybeAndA, maybeAndB] = maybeAnd.value;
+	if (maybeIneqA.name === maybeAndA.name && maybeIneqB.name === maybeAndB.name) return Some([maybeIneqA, maybeIneqB]);
+	if (maybeIneqA.name === maybeAndB.name && maybeIneqB.name === maybeAndA.name) return Some([maybeIneqA, maybeIneqB]);
+	return None;
+}
+function getIneq(expr) {
+	if (expr.type !== AST_NODE_TYPES.BinaryExpression) return None;
+	if (expr.operator !== "!==" && expr.operator !== "!=") return None;
+	if (expr.left.type !== AST_NODE_TYPES.Identifier) return None;
+	if (expr.right.type !== AST_NODE_TYPES.Identifier) return None;
+	return Some([expr.left, expr.right]);
+}
+//#endregion
+export { no_convoluted_boolean_expressions_default as default };

package/dist/rules/no-convoluted-logical-expressions.d.mts

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

package/dist/rules/no-convoluted-logical-expressions.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-convoluted-logical-expressions.ts
 const { name } = path.parse(import.meta.filename);
 var no_convoluted_logical_expressions_default = createRule({
@@ -193,6 +192,5 @@ function isNullishLiteral(node) {
 	if (node.type === AST_NODE_TYPES.Identifier && node.name === "undefined") return true;
 	return false;
 }
-
 //#endregion
-export { no_convoluted_logical_expressions_default as default };
+export { no_convoluted_logical_expressions_default as default };

package/dist/rules/no-custom-url-parsing.d.mts

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

package/dist/rules/no-custom-url-parsing.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-custom-url-parsing.ts
 /**
 * @fileoverview
@@ -55,6 +54,5 @@ var no_custom_url_parsing_default = createRule({
 		};
 	}
 });
-
 //#endregion
-export { no_custom_url_parsing_default as default };
+export { no_custom_url_parsing_default as default };

package/dist/rules/no-disallowed-warning-comments.d.mts

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

package/dist/rules/no-disallowed-warning-comments.mjs

@@ -1,6 +1,5 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
-
 //#region lib/rules/no-disallowed-warning-comments.ts
 const { name } = path.parse(import.meta.filename);
 var no_disallowed_warning_comments_default = createRule({
@@ -81,6 +80,5 @@ function isBadTodo(line) {
 function startsWith(line, keywords) {
 	return keywords.some((keyword) => line.toLowerCase() === keyword.toLowerCase() || suffixes.some((suffix) => startsWithCaseInsensitive(line, `${keyword}${suffix}`)));
 }
-
 //#endregion
-export { no_disallowed_warning_comments_default as default };
+export { no_disallowed_warning_comments_default as default };

package/dist/rules/no-duplicated-return.d.mts

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

package/dist/rules/no-duplicated-return.mjs

@@ -2,7 +2,6 @@ import { createRule } from "../utils/createRule.mjs";
 import { compareTokens } from "../utils/compareTokens.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/no-duplicated-return.ts
 const { name } = path.parse(import.meta.filename);
 var no_duplicated_return_default = createRule({
@@ -76,6 +75,7 @@ function alwaysReturns(stmt) {
 		case AST_NODE_TYPES.IfStatement:
 			if (stmt.alternate && !alwaysReturns(stmt.alternate)) return false;
 			return alwaysReturns(stmt.consequent);
+		case AST_NODE_TYPES.SwitchStatement: return stmt.cases.flatMap((c) => c.consequent).every((c) => alwaysReturns(c));
 		case AST_NODE_TYPES.ForInStatement:
 		case AST_NODE_TYPES.ForOfStatement:
 		case AST_NODE_TYPES.ForStatement:
@@ -88,6 +88,5 @@ function alwaysReturns(stmt) {
 		default: return false;
 	}
 }
-
 //#endregion
-export { no_duplicated_return_default as default };
+export { no_duplicated_return_default as default };

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

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