@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/emptyDestructures.js

@@ -1,32 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyDestructures.ts
-var emptyDestructures_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using empty destructuring patterns that destructure no values.",
-		id: "emptyDestructures",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { emptyPattern: {
-		primary: "Destructuring patterns that don't extract at least one value are unnecessary.",
-		secondary: ["Empty destructuring patterns like `{}` or `[]` don't extract any values and serve no practical purpose.", "These patterns are likely mistakes or leftover code from refactoring."],
-		suggestions: ["Remove the empty destructuring pattern if it's not needed.", "Add bindings to extract values if you intended to destructure specific properties."]
-	} },
-	setup(context) {
-		function checkBindingPattern(node, { sourceFile }) {
-			if (!node.elements.length) context.report({
-				message: "emptyPattern",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		}
-		return { visitors: {
-			ArrayBindingPattern: checkBindingPattern,
-			ObjectBindingPattern: checkBindingPattern
-		} };
-	}
-});
-//#endregion
-export { emptyDestructures_default as default };

package/lib/rules/emptyEnums.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty enum declarations with no members.";
-    readonly id: "emptyEnums";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyEnum", undefined>;
-export default _default;

package/lib/rules/emptyEnums.js

@@ -1,28 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyEnums.ts
-var emptyEnums_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty enum declarations with no members.",
-		id: "emptyEnums",
-		presets: ["logical"]
-	},
-	messages: { emptyEnum: {
-		primary: "Empty enums serve no purpose.",
-		secondary: ["An enum with no members cannot be used to represent any values.", "Empty enums are typically the result of incomplete implementation or mistaken deletion."],
-		suggestions: ["Add members to the enum to define valid values.", "Remove the empty enum if it is no longer needed."]
-	} },
-	setup(context) {
-		return { visitors: { EnumDeclaration: (node, { sourceFile }) => {
-			if (!node.members.length) context.report({
-				message: "emptyEnum",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.name.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { emptyEnums_default as default };

package/lib/rules/emptyExports.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty export statements that don't make a file a module.";
-    readonly id: "emptyExports";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "uselessExport", undefined>;
-export default _default;

package/lib/rules/emptyExports.js

@@ -1,58 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/emptyExports.ts
-const moduleIndicatorKinds = /* @__PURE__ */ new Set([
-	SyntaxKind.ExportAssignment,
-	SyntaxKind.ExportDeclaration,
-	SyntaxKind.ImportDeclaration,
-	SyntaxKind.ImportEqualsDeclaration
-]);
-function hasExportModifier(node) {
-	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
-}
-function hasOtherModuleIndicator(statements) {
-	return statements.some((statement) => hasExportModifier(statement) || moduleIndicatorKinds.has(statement.kind) && !isEmptyNamedExport(statement));
-}
-function isEmptyNamedExport(node) {
-	return node.kind === SyntaxKind.ExportDeclaration && !node.moduleSpecifier && node.exportClause?.kind === SyntaxKind.NamedExports && !node.exportClause.elements.length;
-}
-var emptyExports_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty export statements that don't make a file a module.",
-		id: "emptyExports",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { uselessExport: {
-		primary: "Empty export does nothing and can be removed.",
-		secondary: ["An empty `export {}` statement is only useful when a file has no other imports or exports.", "When a file already has imports or exports, the empty export is redundant."],
-		suggestions: ["Remove the empty export statement."]
-	} },
-	setup(context) {
-		function checkStatements(statements, sourceFile) {
-			if (!hasOtherModuleIndicator(statements)) return;
-			for (const statement of statements) {
-				if (!isEmptyNamedExport(statement)) continue;
-				const range = getTSNodeRange(statement, sourceFile);
-				context.report({
-					fix: {
-						range,
-						text: ""
-					},
-					message: "uselessExport",
-					range
-				});
-			}
-		}
-		return { visitors: {
-			ModuleBlock: (node, { sourceFile }) => {
-				checkStatements(node.statements, sourceFile);
-			},
-			SourceFile: (node, { sourceFile }) => {
-				if (!sourceFile.fileName.endsWith(".d.ts")) checkStatements(node.statements, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { emptyExports_default as default };

package/lib/rules/emptyFiles.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports files that contain no meaningful code.";
-    readonly id: "emptyFiles";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyFile", undefined>;
-export default _default;

package/lib/rules/emptyFiles.js

@@ -1,42 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/emptyFiles.ts
-function isDirective(statement) {
-	return statement.kind === SyntaxKind.ExpressionStatement && statement.expression.kind === SyntaxKind.StringLiteral && /^use \w+$/.test(statement.expression.text);
-}
-function isEmptyStatement(statement) {
-	switch (statement.kind) {
-		case SyntaxKind.Block: return !statement.statements.length;
-		case SyntaxKind.EmptyStatement: return true;
-		default: return false;
-	}
-}
-function isMeaningfulStatement(statement) {
-	return !isEmptyStatement(statement) && !isDirective(statement);
-}
-var emptyFiles_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports files that contain no meaningful code.",
-		id: "emptyFiles",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyFile: {
-		primary: "This file contains no meaningful code.",
-		secondary: ["Empty files clutter the codebase and often serve no purpose.", "Files containing only whitespace, comments, directives, or empty statements are considered empty."],
-		suggestions: ["Add meaningful code to the file.", "Delete the file if it's no longer needed."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile: (sourceFile) => {
-			if (!sourceFile.isDeclarationFile && !sourceFile.statements.some(isMeaningfulStatement)) context.report({
-				message: "emptyFile",
-				range: {
-					begin: 0,
-					end: 0
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { emptyFiles_default as default };

package/lib/rules/emptyFunctions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty functions that should contain code or a comment.";
-    readonly id: "emptyFunctions";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyFunction", undefined>;
-export default _default;

package/lib/rules/emptyFunctions.js

@@ -1,59 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/emptyFunctions.ts
-function hasComments(block, sourceFile) {
-	const fullText = sourceFile.getFullText();
-	const openBrace = block.getStart(sourceFile);
-	const closeBrace = block.getEnd();
-	const innerText = fullText.substring(openBrace + 1, closeBrace - 1);
-	return /\S+/.test(innerText.trim());
-}
-function isEmptyBlock(block, sourceFile) {
-	return !block.statements.length && !hasComments(block, sourceFile);
-}
-var emptyFunctions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty functions that should contain code or a comment.",
-		id: "emptyFunctions",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyFunction: {
-		primary: "Empty functions should contain code or a comment explaining why they are empty.",
-		secondary: ["Empty functions can reduce readability because readers need to guess whether it's intentional or not.", "Adding a comment makes the intention clear."],
-		suggestions: ["Add a comment explaining why the function is intentionally empty.", "Add to the function body."]
-	} },
-	setup(context) {
-		function checkFunctionBody(node, body, sourceFile) {
-			if (body && isEmptyBlock(body, sourceFile)) context.report({
-				message: "emptyFunction",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			ArrowFunction: (node, { sourceFile }) => {
-				if (node.body.kind === SyntaxKind.Block) checkFunctionBody(node, node.body, sourceFile);
-			},
-			Constructor: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			FunctionDeclaration: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			FunctionExpression: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			GetAccessor: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			MethodDeclaration: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			},
-			SetAccessor: (node, { sourceFile }) => {
-				checkFunctionBody(node, node.body, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { emptyFunctions_default as default };

package/lib/rules/emptyModuleAttributes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty import/export attributes that serve no purpose.";
-    readonly id: "emptyModuleAttributes";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyAttributes", undefined>;
-export default _default;

package/lib/rules/emptyModuleAttributes.js

@@ -1,33 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/emptyModuleAttributes.ts
-var emptyModuleAttributes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports empty import/export attributes that serve no purpose.",
-		id: "emptyModuleAttributes",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { emptyAttributes: {
-		primary: "Empty import attributes serve no purpose and should be removed.",
-		secondary: ["An empty `with {}` or `assert {}` clause provides no additional information about the import.", "Remove the empty attributes clause or add the intended attributes."],
-		suggestions: ["Remove the empty attributes clause."]
-	} },
-	setup(context) {
-		function checkNode({ attributes }, { sourceFile }) {
-			if (attributes && !attributes.elements.length) context.report({
-				fix: {
-					range: getTSNodeRange(attributes, sourceFile),
-					text: ""
-				},
-				message: "emptyAttributes",
-				range: getTSNodeRange(attributes, sourceFile)
-			});
-		}
-		return { visitors: {
-			ExportDeclaration: checkNode,
-			ImportDeclaration: checkNode
-		} };
-	}
-});
-//#endregion
-export { emptyModuleAttributes_default as default };

package/lib/rules/emptyObjectTypes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty object type literals and empty interfaces that are often used incorrectly.";
-    readonly id: "emptyObjectTypes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyInterface" | "emptyObjectType", undefined>;
-export default _default;

package/lib/rules/emptyObjectTypes.js

@@ -1,45 +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 };

package/lib/rules/emptyStaticBlocks.d.ts

@@ -1,9 +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;

package/lib/rules/emptyStaticBlocks.js

@@ -1,40 +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 };

package/lib/rules/emptyTypeParameterLists.d.ts

@@ -1,9 +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;

package/lib/rules/emptyTypeParameterLists.js

@@ -1,29 +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 };

package/lib/rules/enumInitializers.d.ts

@@ -1,9 +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;

package/lib/rules/enumInitializers.js

@@ -1,52 +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 };

package/lib/rules/enumMemberLiterals.d.ts

@@ -1,9 +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;

package/lib/rules/enumMemberLiterals.js

@@ -1,37 +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$1(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$1(node.initializer)) context.report({
-				message: "requireLiteral",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { enumMemberLiterals_default as default };

package/lib/rules/enumValueConsistency.d.ts

@@ -1,9 +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;

package/lib/rules/enumValueConsistency.js

@@ -1,54 +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 };

package/lib/rules/enumValueDuplicates.d.ts

@@ -1,9 +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;