@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/emptyObjectTypes.js

@@ -1,47 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/emptyObjectTypes.ts
-var emptyObjectTypes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty object type literals and empty interfaces that are often used incorrectly.",
-		id: "emptyObjectTypes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		emptyInterface: {
-			primary: "Empty interfaces are often used incorrectly and should be avoided.",
-			secondary: ["An empty interface `interface Foo {}` is equivalent to the `{}` type, which matches any non-nullish value.", "Consider using `object` for any object, `unknown` for any value, or adding members to the interface."],
-			suggestions: ["Add members to the interface, or use `object` or `unknown` instead."]
-		},
-		emptyObjectType: {
-			primary: "The `{}` type means 'any non-nullish value' and is often used incorrectly.",
-			secondary: ["The `{}` type allows any value except `null` and `undefined`, including primitives like strings and numbers.", "If you want to represent any object, use `object`. If you want any value, use `unknown`."],
-			suggestions: ["Use `object` for any object value, or `unknown` for any value including `null` and `undefined`."]
-		}
-	},
-	setup(context) {
-		return { visitors: {
-			InterfaceDeclaration: (node, { sourceFile }) => {
-				if (node.members.length) return false;
-				const extendsClause = node.heritageClauses?.find((clause) => clause.token === SyntaxKind.ExtendsKeyword);
-				if (extendsClause && extendsClause.types.length > 1) return;
-				context.report({
-					message: "emptyInterface",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			},
-			TypeLiteral: (node, { sourceFile }) => {
-				if (node.members.length || node.parent.kind === SyntaxKind.IntersectionType || node.parent.kind === SyntaxKind.MappedType) return;
-				context.report({
-					message: "emptyObjectType",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { emptyObjectTypes_default as default };
-
-//# sourceMappingURL=emptyObjectTypes.js.map

package/lib/rules/emptyStaticBlocks.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty static initialization blocks within class declarations.";
-    readonly id: "emptyStaticBlocks";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyStaticBlock", undefined>;
-export default _default;
-//# sourceMappingURL=emptyStaticBlocks.d.ts.map

package/lib/rules/emptyStaticBlocks.js

@@ -1,42 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyStaticBlocks.ts
-var emptyStaticBlocks_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty static initialization blocks within class declarations.",
-		id: "emptyStaticBlocks",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyStaticBlock: {
-		primary: "Empty static blocks serve no purpose and should be removed for cleaner code.",
-		secondary: ["Static blocks are used to initialize static class properties or perform other one-time setup when a class is loaded.", "An empty static block has no statements and therefore serves no purpose."],
-		suggestions: ["Remove the empty static block, or add initialization logic if needed."]
-	} },
-	setup(context) {
-		return { visitors: { ClassStaticBlockDeclaration: (node, { sourceFile }) => {
-			if (node.body.statements.length) return;
-			const openBrace = node.body.getFirstToken(sourceFile);
-			if (!openBrace) return;
-			const range = {
-				begin: node.getStart(sourceFile),
-				end: openBrace.getEnd()
-			};
-			context.report({
-				message: "emptyStaticBlock",
-				range,
-				suggestions: [{
-					id: "removeEmptyStaticBlock",
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					},
-					text: ""
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { emptyStaticBlocks_default as default };
-
-//# sourceMappingURL=emptyStaticBlocks.js.map

package/lib/rules/emptyTypeParameterLists.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty type parameter lists in type aliases and interfaces.";
-    readonly id: "emptyTypeParameterLists";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyTypeParameters", undefined>;
-export default _default;
-//# sourceMappingURL=emptyTypeParameterLists.d.ts.map

package/lib/rules/emptyTypeParameterLists.js

@@ -1,31 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyTypeParameterLists.ts
-var emptyTypeParameterLists_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty type parameter lists in type aliases and interfaces.",
-		id: "emptyTypeParameterLists",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyTypeParameters: {
-		primary: "Empty type parameter lists are unnecessary.",
-		secondary: ["TypeScript permits empty type parameter lists like `<>`, but this practice is discouraged.", "Empty type parameter lists can lead to unclear or ambiguous code."],
-		suggestions: ["Remove the empty type parameter list, or add type parameters if needed."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile }) {
-			if (node.typeParameters && !node.typeParameters.length) context.report({
-				message: "emptyTypeParameters",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			InterfaceDeclaration: checkNode,
-			TypeAliasDeclaration: checkNode
-		} };
-	}
-});
-//#endregion
-export { emptyTypeParameterLists_default as default };
-
-//# sourceMappingURL=emptyTypeParameterLists.js.map

package/lib/rules/enumInitializers.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports enum members without explicit initial values.";
-    readonly id: "enumInitializers";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "defineInitializer", undefined>;
-export default _default;
-//# sourceMappingURL=enumInitializers.d.ts.map

package/lib/rules/enumInitializers.js

@@ -1,54 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/enumInitializers.ts
-var enumInitializers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports enum members without explicit initial values.",
-		id: "enumInitializers",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { defineInitializer: {
-		primary: "Enum member '{{ name }}' has an implicit initializer that may change if the enum is reordered.",
-		secondary: ["Enum members without explicit values are assigned sequentially increasing numbers.", "This can cause unintended value changes if enum members are reordered or removed."],
-		suggestions: ["For numeric enums, add an index-based value such as `{{ name }} = {{ suggestedIndex }}`.", "For string enums, add a string value such as `{{ name }} = '{{ name }}'`."]
-	} },
-	setup(context) {
-		return { visitors: { EnumDeclaration: (node, { sourceFile }) => {
-			for (const [index, member] of node.members.entries()) {
-				if (member.initializer !== void 0) continue;
-				const name = member.name.kind === SyntaxKind.Identifier ? member.name.text : member.name.getText(sourceFile);
-				const range = getTSNodeRange(member, sourceFile);
-				context.report({
-					data: {
-						name,
-						suggestedIndex: index
-					},
-					message: "defineInitializer",
-					range,
-					suggestions: [
-						{
-							id: "assignIndex",
-							range,
-							text: `${name} = ${index}`
-						},
-						{
-							id: "assignIncrementedIndex",
-							range,
-							text: `${name} = ${index + 1}`
-						},
-						{
-							id: "assignStringValue",
-							range,
-							text: `${name} = '${name}'`
-						}
-					]
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { enumInitializers_default as default };
-
-//# sourceMappingURL=enumInitializers.js.map

package/lib/rules/enumMemberLiterals.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Requires all enum members to be literal values.";
-    readonly id: "enumMemberLiterals";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "requireLiteral", undefined>;
-export default _default;
-//# sourceMappingURL=enumMemberLiterals.d.ts.map

package/lib/rules/enumMemberLiterals.js

@@ -1,39 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/enumMemberLiterals.ts
-function isLiteralExpression(expression) {
-	switch (expression.kind) {
-		case SyntaxKind.NoSubstitutionTemplateLiteral:
-		case SyntaxKind.NumericLiteral:
-		case SyntaxKind.StringLiteral: return true;
-		case SyntaxKind.PrefixUnaryExpression:
-			if (expression.operator === SyntaxKind.PlusToken || expression.operator === SyntaxKind.MinusToken) return expression.operand.kind === SyntaxKind.NumericLiteral;
-			return false;
-		default: return false;
-	}
-}
-var enumMemberLiterals_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Requires all enum members to be literal values.",
-		id: "enumMemberLiterals",
-		presets: ["logicalStrict"]
-	},
-	messages: { requireLiteral: {
-		primary: "Prefer initializing enum members with literal values for predictability.",
-		secondary: ["Using computed values in enum initializers can lead to unexpected results.", "Enum members create their own scope, so variable references may not work as expected."],
-		suggestions: ["Use a literal string or number value instead of a computed expression."]
-	} },
-	setup(context) {
-		return { visitors: { EnumMember: (node, { sourceFile }) => {
-			if (node.initializer && !isLiteralExpression(node.initializer)) context.report({
-				message: "requireLiteral",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { enumMemberLiterals_default as default };
-
-//# sourceMappingURL=enumMemberLiterals.js.map

package/lib/rules/enumValueConsistency.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports enums that contain both string and number members.";
-    readonly id: "enumValueConsistency";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "mixedTypes", undefined>;
-export default _default;
-//# sourceMappingURL=enumValueConsistency.d.ts.map

package/lib/rules/enumValueConsistency.js

@@ -1,56 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/enumValueConsistency.ts
-const enumMemberKinds = {
-	Number: "number",
-	String: "string",
-	Unknown: "unknown"
-};
-function getEnumMemberKind(member, typeChecker) {
-	const type = typeChecker.getTypeAtLocation(member);
-	if (type.isNumberLiteral()) {
-		if ((type.flags & ts.TypeFlags.NumberLike) !== 0) return enumMemberKinds.Number;
-	} else if (type.isStringLiteral() && (type.flags & ts.TypeFlags.StringLike) !== 0) return enumMemberKinds.String;
-	return enumMemberKinds.Unknown;
-}
-var enumValueConsistency_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports enums that contain both string and number members.",
-		id: "enumValueConsistency",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { mixedTypes: {
-		primary: "Enum '{{ name }}' contains both number and string members, which can cause unexpected iteration behavior.",
-		secondary: [
-			"When iterating over a mixed enum with Object.keys(), Object.values(), or Object.entries(), numeric members will also include reverse mappings.",
-			"This results in a different number of items than the actual enum members.",
-			"Pure string enums don't have this issue since they don't create reverse mappings."
-		],
-		suggestions: ["Convert all members to strings for predictable iteration.", "Convert all members to numbers if reverse mappings are intentional."]
-	} },
-	setup(context) {
-		return { visitors: { EnumDeclaration: (node, { sourceFile, typeChecker }) => {
-			if (node.members.length < 2) return;
-			let hasNumber = false;
-			let hasString = false;
-			for (const member of node.members) {
-				const kind = getEnumMemberKind(member, typeChecker);
-				if (kind === enumMemberKinds.Number) hasNumber = true;
-				else if (kind === enumMemberKinds.String) hasString = true;
-				if (hasNumber && hasString) {
-					context.report({
-						data: { name: node.name.text },
-						message: "mixedTypes",
-						range: getTSNodeRange(node.name, sourceFile)
-					});
-					return;
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { enumValueConsistency_default as default };
-
-//# sourceMappingURL=enumValueConsistency.js.map

package/lib/rules/enumValueDuplicates.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports enum members with duplicate values.";
-    readonly id: "enumValueDuplicates";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicateValue", undefined>;
-export default _default;
-//# sourceMappingURL=enumValueDuplicates.d.ts.map

package/lib/rules/enumValueDuplicates.js

@@ -1,60 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/enumValueDuplicates.ts
-function getLiteralValue(initializer) {
-	switch (initializer.kind) {
-		case SyntaxKind.NoSubstitutionTemplateLiteral:
-		case SyntaxKind.StringLiteral: return initializer.text;
-		case SyntaxKind.NumericLiteral: return Number(initializer.text);
-		case SyntaxKind.PrefixUnaryExpression: {
-			if (initializer.operand.kind !== SyntaxKind.NumericLiteral) return;
-			const value = Number(initializer.operand.text);
-			if (initializer.operator === SyntaxKind.MinusToken) return -value;
-			if (initializer.operator === SyntaxKind.PlusToken) return value;
-			return;
-		}
-		default: return;
-	}
-}
-var enumValueDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports enum members with duplicate values.",
-		id: "enumValueDuplicates",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { duplicateValue: {
-		primary: "Enum member '{{ name }}' has a duplicate value '{{ value }}' which is already used by '{{ firstMember }}'.",
-		secondary: ["Duplicate enum values can lead to hard-to-track bugs since different members may be indistinguishable at runtime.", "When accessing enum members by value, only one of the duplicate members will be returned."],
-		suggestions: ["Use a unique value for each enum member.", "If duplication is intentional (e.g., for aliasing), consider using a type union instead."]
-	} },
-	setup(context) {
-		return { visitors: { EnumDeclaration: (node, { sourceFile }) => {
-			const seenValues = /* @__PURE__ */ new Map();
-			for (const member of node.members) {
-				if (!member.initializer) continue;
-				const value = getLiteralValue(member.initializer);
-				if (value === void 0) continue;
-				const memberName = member.name.kind === SyntaxKind.Identifier ? member.name.text : member.name.getText(sourceFile);
-				const firstMember = seenValues.get(value);
-				if (firstMember === void 0) {
-					seenValues.set(value, memberName);
-					continue;
-				}
-				context.report({
-					data: {
-						firstMember,
-						name: memberName,
-						value: String(value)
-					},
-					message: "duplicateValue",
-					range: getTSNodeRange(member, sourceFile)
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { enumValueDuplicates_default as default };
-
-//# sourceMappingURL=enumValueDuplicates.js.map

package/lib/rules/equalityOperatorNegations.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports negated expressions on the left side of equality checks.";
-    readonly id: "equalityOperatorNegations";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "negatedEquality", undefined>;
-export default _default;
-//# sourceMappingURL=equalityOperatorNegations.d.ts.map

package/lib/rules/equalityOperatorNegations.js

@@ -1,60 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/equalityOperatorNegations.ts
-const equalityOperators = new Set([
-	SyntaxKind.EqualsEqualsEqualsToken,
-	SyntaxKind.EqualsEqualsToken,
-	SyntaxKind.ExclamationEqualsEqualsToken,
-	SyntaxKind.ExclamationEqualsToken
-]);
-const operatorStrings = new Map([
-	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
-	[SyntaxKind.EqualsEqualsToken, "=="],
-	[SyntaxKind.ExclamationEqualsEqualsToken, "!=="],
-	[SyntaxKind.ExclamationEqualsToken, "!="]
-]);
-const negatedOperators = new Map([
-	[SyntaxKind.EqualsEqualsEqualsToken, "!=="],
-	[SyntaxKind.EqualsEqualsToken, "!="],
-	[SyntaxKind.ExclamationEqualsEqualsToken, "==="],
-	[SyntaxKind.ExclamationEqualsToken, "=="]
-]);
-var equalityOperatorNegations_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports negated expressions on the left side of equality checks.",
-		id: "equalityOperatorNegations"
-	},
-	messages: { negatedEquality: {
-		primary: "Negating the left operand of '{{ operator }}' is likely a mistake.",
-		secondary: ["The logical not operator (!) applies to the left operand before the equality comparison.", "This converts the left operand to a boolean before comparing, which is rarely intended."],
-		suggestions: ["Use the opposite equality operator ('{{ suggested }}') and remove the negation."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (!equalityOperators.has(node.operatorToken.kind)) return;
-			const left = unwrapParenthesizedNode(node.left);
-			if (left.kind !== SyntaxKind.PrefixUnaryExpression || left.operator !== SyntaxKind.ExclamationToken) return;
-			const innerExpression = unwrapParenthesizedNode(left.operand);
-			if (innerExpression.kind === SyntaxKind.PrefixUnaryExpression && innerExpression.operator === SyntaxKind.ExclamationToken) return;
-			const begin = left.getStart(sourceFile);
-			const operator = operatorStrings.get(node.operatorToken.kind);
-			const suggested = negatedOperators.get(node.operatorToken.kind);
-			context.report({
-				data: {
-					operator,
-					suggested
-				},
-				message: "negatedEquality",
-				range: {
-					begin,
-					end: begin + 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { equalityOperatorNegations_default as default };
-
-//# sourceMappingURL=equalityOperatorNegations.js.map

package/lib/rules/equalityOperators.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.";
-    readonly id: "equalityOperators";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferStrictEquality", undefined>;
-export default _default;
-//# sourceMappingURL=equalityOperators.d.ts.map

package/lib/rules/equalityOperators.js

@@ -1,44 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isNullishLiteral, toEqualityOperator, toStrictOperator } from "./utils/equalityOperators.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/equalityOperators.ts
-var equalityOperators_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.",
-		id: "equalityOperators",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferStrictEquality: {
-		primary: "Use the more precise strict equality ('{{ strictOperator }}') instead of the loose '{{ looseOperator }}'.",
-		secondary: ["The loose equality operators '=='/'!=' perform arcane type coercion and are difficult to reason about.", "Use strict equality operators '==='/'!==' instead."],
-		suggestions: ["Replace '{{ looseOperator }}' with '{{ strictOperator }}'."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			const operator = toEqualityOperator(node.operatorToken.kind);
-			if (operator == null) return;
-			if (isNullishLiteral(node.left) || isNullishLiteral(node.right)) return;
-			if (operator === "==" || operator === "!=") {
-				const strictOperator = toStrictOperator(operator);
-				const operatorRange = getTSNodeRange(node.operatorToken, sourceFile);
-				context.report({
-					data: {
-						looseOperator: operator,
-						strictOperator
-					},
-					message: "preferStrictEquality",
-					range: operatorRange,
-					suggestions: [{
-						id: "useStrictOperator",
-						range: operatorRange,
-						text: strictOperator
-					}]
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { equalityOperators_default as default };
-
-//# sourceMappingURL=equalityOperators.js.map

package/lib/rules/errorMessages.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Requires a message value when creating a built-in error.";
-    readonly id: "errorMessages";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingMessage", undefined>;
-export default _default;
-//# sourceMappingURL=errorMessages.d.ts.map

package/lib/rules/errorMessages.js

@@ -1,60 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/errorMessages.ts
-const errorConstructors = [
-	"AggregateError",
-	"Error",
-	"EvalError",
-	"RangeError",
-	"ReferenceError",
-	"SyntaxError",
-	"TypeError",
-	"URIError"
-];
-function getErrorConstructorWithoutMessage(node, typeChecker) {
-	if (node.expression.kind !== SyntaxKind.Identifier || hasValidMessageArgument(node.arguments)) return false;
-	return errorConstructors.find((errorConstructor) => isGlobalDeclarationOfName(node.expression, errorConstructor, typeChecker));
-}
-function hasValidMessageArgument(args) {
-	if (!args?.length) return false;
-	const firstArgument = args[0];
-	return !!firstArgument && !isEmptyString(firstArgument) && !isUndefinedLiteral(firstArgument);
-}
-function isEmptyString(node) {
-	if (node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral) return node.text === "";
-	return false;
-}
-function isUndefinedLiteral(node) {
-	return node.kind === SyntaxKind.Identifier && node.text === "undefined";
-}
-var errorMessages_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Requires a message value when creating a built-in error.",
-		id: "errorMessages",
-		presets: ["logicalStrict"]
-	},
-	messages: { missingMessage: {
-		primary: "`{{ errorConstructor }}`s created without a message are generally harder to debug.",
-		secondary: ["Error instances without messages are harder to debug because they don't explain what went wrong.", "A descriptive error message helps developers understand and fix issues more quickly."],
-		suggestions: ["Provide a string message describing what caused the error."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile, typeChecker }) {
-			const errorConstructor = getErrorConstructorWithoutMessage(node, typeChecker);
-			if (errorConstructor) context.report({
-				data: { errorConstructor },
-				message: "missingMessage",
-				range: getTSNodeRange(node.expression, sourceFile)
-			});
-		}
-		return { visitors: {
-			CallExpression: checkNode,
-			NewExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { errorMessages_default as default };
-
-//# sourceMappingURL=errorMessages.js.map

package/lib/rules/errorSubclassProperties.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports incorrect Error subclass definitions that don't follow best practices.";
-    readonly id: "errorSubclassProperties";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidClassName" | "missingName" | "redundantMessage" | "useConstructorName" | "wrongName", undefined>;
-export default _default;
-//# sourceMappingURL=errorSubclassProperties.d.ts.map