@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/structuredCloneMethods.js

@@ -1,39 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/structuredCloneMethods.ts
-function isJsonMethod(node, methodName, typeChecker) {
-	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && ts$1.isIdentifier(node.expression.expression) && isGlobalDeclarationOfName(node.expression.expression, "JSON", typeChecker) && node.expression.expression.text === "JSON" && node.expression.name.text === methodName;
-}
-var structuredCloneMethods_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports JSON.parse(JSON.stringify()) patterns that can use structuredClone.",
-		id: "structuredCloneMethods",
-		presets: ["logical"]
-	},
-	messages: { preferStructuredClone: {
-		primary: "Prefer `structuredClone()` over `JSON.parse(JSON.stringify())`.",
-		secondary: ["structuredClone is the native deep cloning API available in modern JavaScript.", "It properly handles circular references and more data types than JSON methods."],
-		suggestions: ["Replace with structuredClone()."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
-			if (!isJsonMethod(node, "parse", typeChecker) || node.arguments.length !== 1) return;
-			const argument = node.arguments[0];
-			if (ts$1.isSpreadElement(argument) || !isJsonMethod(argument, "stringify", typeChecker) || argument.arguments.length !== 1) return;
-			const stringifyArgument = argument.arguments[0];
-			if (ts$1.isSpreadElement(stringifyArgument)) return;
-			context.report({
-				message: "preferStructuredClone",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { structuredCloneMethods_default as default };
-
-//# sourceMappingURL=structuredCloneMethods.js.map

package/lib/rules/symbolDescriptions.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports Symbol() calls without description arguments.";
-    readonly id: "symbolDescriptions";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingDescription", undefined>;
-export default _default;
-//# sourceMappingURL=symbolDescriptions.d.ts.map

package/lib/rules/symbolDescriptions.js

@@ -1,32 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/symbolDescriptions.ts
-var symbolDescriptions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports Symbol() calls without description arguments.",
-		id: "symbolDescriptions",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { missingDescription: {
-		primary: "Symbols without descriptions are more difficult to debug or reason about.",
-		secondary: ["Creating a symbol without a description makes debugging difficult, as the symbol's purpose isn't clear when inspecting it.", "While the description doesn't affect the symbol's uniqueness, it appears in the symbol's string representation and can be accessed via `Symbol.prototype.description`."],
-		suggestions: ["Add a descriptive string argument to the Symbol constructor that explains the symbol's purpose."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile }) => {
-			if (node.expression.kind !== SyntaxKind.Identifier || node.expression.text !== "Symbol" || node.arguments.length) return;
-			context.report({
-				message: "missingDescription",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { symbolDescriptions_default as default };
-
-//# sourceMappingURL=symbolDescriptions.js.map

package/lib/rules/thisAliases.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports assigning `this` to a variable.";
-    readonly id: "thisAliases";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noThisAlias", undefined>;
-export default _default;
-//# sourceMappingURL=thisAliases.d.ts.map

package/lib/rules/thisAliases.js

@@ -1,44 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/thisAliases.ts
-var thisAliases_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports assigning `this` to a variable.",
-		id: "thisAliases",
-		presets: ["logical"]
-	},
-	messages: { noThisAlias: {
-		primary: "Assigning `this` to a variable is unnecessary with arrow functions.",
-		secondary: ["Arrow functions preserve the surrounding `this` context automatically.", "Aliasing `this` is a pre-ES2015 pattern that is no longer needed."],
-		suggestions: ["Use arrow functions to preserve the `this` context.", "Access `this` directly instead of through an alias."]
-	} },
-	setup(context) {
-		return { visitors: {
-			BinaryExpression(node, { sourceFile }) {
-				if (node.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || node.right.kind !== ts$1.SyntaxKind.ThisKeyword || !ts$1.isIdentifier(node.left)) return;
-				context.report({
-					message: "noThisAlias",
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					}
-				});
-			},
-			VariableDeclaration(node, { sourceFile }) {
-				if (node.initializer?.kind !== ts$1.SyntaxKind.ThisKeyword || !ts$1.isIdentifier(node.name)) return;
-				context.report({
-					message: "noThisAlias",
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					}
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { thisAliases_default as default };
-
-//# sourceMappingURL=thisAliases.js.map

package/lib/rules/thisBeforeSuper.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using `this` or `super` before calling `super()` in derived class constructors.";
-    readonly id: "thisBeforeSuper";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "thisBeforeSuper" | "superBeforeSuper", undefined>;
-export default _default;
-//# sourceMappingURL=thisBeforeSuper.d.ts.map

package/lib/rules/thisBeforeSuper.js

@@ -1,86 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/thisBeforeSuper.ts
-function findAllThisOrSuper(node, sourceFile, results) {
-	if (isNestedScope(node)) return;
-	if (node.kind === ts$1.SyntaxKind.ThisKeyword) {
-		results.push(node);
-		return;
-	}
-	if (node.kind === ts$1.SyntaxKind.SuperKeyword && ts$1.isPropertyAccessExpression(node.parent)) {
-		results.push(node);
-		return;
-	}
-	ts$1.forEachChild(node, (child) => {
-		findAllThisOrSuper(child, sourceFile, results);
-	});
-}
-function findAllThisOrSuperBeforePosition(node, position, sourceFile, results) {
-	if (node.getStart(sourceFile) >= position) return;
-	if (isNestedScope(node)) return;
-	if (node.kind === ts$1.SyntaxKind.ThisKeyword) {
-		results.push(node);
-		return;
-	}
-	if (node.kind === ts$1.SyntaxKind.SuperKeyword && ts$1.isPropertyAccessExpression(node.parent)) {
-		results.push(node);
-		return;
-	}
-	ts$1.forEachChild(node, (child) => {
-		findAllThisOrSuperBeforePosition(child, position, sourceFile, results);
-	});
-}
-function findFirstSuperCall(node) {
-	if (isNestedScope(node)) return;
-	if (ts$1.isCallExpression(node) && node.expression.kind === ts$1.SyntaxKind.SuperKeyword) return node;
-	return ts$1.forEachChild(node, (child) => {
-		return findFirstSuperCall(child);
-	});
-}
-function isNestedScope(node) {
-	return ts$1.isFunctionDeclaration(node) || ts$1.isFunctionExpression(node) || ts$1.isArrowFunction(node) || ts$1.isClassDeclaration(node) || ts$1.isClassExpression(node);
-}
-var thisBeforeSuper_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using `this` or `super` before calling `super()` in derived class constructors.",
-		id: "thisBeforeSuper",
-		presets: ["javascript"]
-	},
-	messages: {
-		superBeforeSuper: {
-			primary: "`super` property access is not allowed before `super()` in derived class constructors.",
-			secondary: ["Accessing `super.property` before calling `super()` throws a ReferenceError."],
-			suggestions: ["Move `super()` before any use of `super.property`."]
-		},
-		thisBeforeSuper: {
-			primary: "`this` is not allowed before `super()` in derived class constructors.",
-			secondary: ["Accessing `this` before calling `super()` throws a ReferenceError.", "The `super()` call must be the first statement that accesses the instance."],
-			suggestions: ["Move `super()` before any use of `this`."]
-		}
-	},
-	setup(context) {
-		return { visitors: { Constructor(node, { sourceFile }) {
-			if (!node.parent.heritageClauses) return;
-			if (!node.parent.heritageClauses.some((clause) => clause.token === ts$1.SyntaxKind.ExtendsKeyword) || !node.body) return;
-			const superCall = findFirstSuperCall(node.body);
-			const invalidNodes = [];
-			if (superCall) {
-				const superCallStart = superCall.getStart(sourceFile);
-				findAllThisOrSuperBeforePosition(node.body, superCallStart, sourceFile, invalidNodes);
-				for (const arg of superCall.arguments) findAllThisOrSuper(arg, sourceFile, invalidNodes);
-			} else findAllThisOrSuper(node.body, sourceFile, invalidNodes);
-			for (const invalidNode of invalidNodes) context.report({
-				message: invalidNode.kind === ts$1.SyntaxKind.ThisKeyword ? "thisBeforeSuper" : "superBeforeSuper",
-				range: {
-					begin: invalidNode.getStart(sourceFile),
-					end: invalidNode.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { thisBeforeSuper_default as default };
-
-//# sourceMappingURL=thisBeforeSuper.js.map

package/lib/rules/throwErrors.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports throwing values that are not `Error` objects.";
-    readonly id: "throwErrors";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "throwError" | "throwUndefined", undefined>;
-export default _default;
-//# sourceMappingURL=throwErrors.d.ts.map

package/lib/rules/throwErrors.js

@@ -1,61 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { declarationIncludesGlobal, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/throwErrors.ts
-function isBuiltinErrorType(type) {
-	const symbol = type.getSymbol();
-	if (symbol?.getName() !== "Error") return false;
-	return !!symbol.getDeclarations()?.some(declarationIncludesGlobal);
-}
-function isErrorType(type) {
-	if (isBuiltinErrorType(type)) return true;
-	if (type.isUnion()) return type.types.every((t) => isErrorType(t));
-	if (type.isIntersection()) return type.types.some((t) => isErrorType(t));
-	const baseTypes = type.getBaseTypes();
-	if (baseTypes) {
-		for (const baseType of baseTypes) if (isErrorType(baseType)) return true;
-	}
-	return false;
-}
-var throwErrors_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports throwing values that are not `Error` objects.",
-		id: "throwErrors",
-		presets: ["logical"]
-	},
-	messages: {
-		throwError: {
-			primary: "Only `Error` objects should be thrown.",
-			secondary: ["Throwing non-`Error` values loses stack trace information.", "Error objects provide consistent behavior and debugging information."],
-			suggestions: ["Wrap the value in an `Error`: `throw new Error(value)`.", "Create a custom `Error` class for specific error types."]
-		},
-		throwUndefined: {
-			primary: "Throwing `undefined` provides no context and is hard to debug.",
-			secondary: ["Throw an `Error` to preserve stack trace and debugging details.", "If you need a custom error type, extend `Error`."],
-			suggestions: ["Throw a new `Error`: `throw new Error(\"message\")`.", "Create a custom `Error` class for specific error types."]
-		}
-	},
-	setup(context) {
-		return { visitors: { ThrowStatement(node, { sourceFile, typeChecker }) {
-			const type = getConstrainedTypeAtLocation(node.expression, typeChecker);
-			if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown) || isErrorType(type)) return;
-			if (type.isUnion() ? type.types.every((t) => tsutils.isTypeFlagSet(t, ts$1.TypeFlags.Undefined)) : tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Undefined)) {
-				context.report({
-					message: "throwUndefined",
-					range: getTSNodeRange(node.expression, sourceFile)
-				});
-				return;
-			}
-			context.report({
-				message: "throwError",
-				range: getTSNodeRange(node.expression, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { throwErrors_default as default };
-
-//# sourceMappingURL=throwErrors.js.map

package/lib/rules/topLevelAwaits.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports top-level await expressions in files that export values.";
-    readonly id: "topLevelAwaits";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "topLevelAwait", undefined>;
-export default _default;
-//# sourceMappingURL=topLevelAwaits.d.ts.map

package/lib/rules/topLevelAwaits.js

@@ -1,49 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/topLevelAwaits.ts
-function hasExportModifier(node) {
-	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
-}
-function isInsideFunction(node) {
-	let current = node.parent;
-	while (current) {
-		if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current) || ts.isConstructorDeclaration(current) || ts.isGetAccessorDeclaration(current) || ts.isSetAccessorDeclaration(current)) return true;
-		current = current.parent;
-	}
-	return false;
-}
-var topLevelAwaits_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports top-level await expressions in files that export values.",
-		id: "topLevelAwaits",
-		presets: ["logicalStrict"]
-	},
-	messages: { topLevelAwait: {
-		primary: "Top-level await in a module file causes imports from the module to wait on the asynchronous work.",
-		secondary: ["Modules using top-level await block their dependents until the await resolves.", "This can cause unexpected delays in application startup."],
-		suggestions: ["Wrap the await in an async function that is called at the appropriate time.", "Use dynamic imports with `.then()` for lazy loading."]
-	} },
-	setup(context) {
-		let fileHasExports;
-		return { visitors: {
-			AwaitExpression(node, { sourceFile }) {
-				if (!fileHasExports || isInsideFunction(node)) return;
-				context.report({
-					message: "topLevelAwait",
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.expression.getStart(sourceFile)
-					}
-				});
-			},
-			SourceFile(node) {
-				fileHasExports = node.statements.some((statement) => hasExportModifier(statement) || statement.kind === SyntaxKind.ExportAssignment || statement.kind === SyntaxKind.ExportDeclaration);
-			}
-		} };
-	}
-});
-//#endregion
-export { topLevelAwaits_default as default };
-
-//# sourceMappingURL=topLevelAwaits.js.map

package/lib/rules/tripleSlashReferenceValidity.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports invalid triple-slash reference directives.";
-    readonly id: "tripleSlashReferenceValidity";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidDirective", undefined>;
-export default _default;
-//# sourceMappingURL=tripleSlashReferenceValidity.d.ts.map

package/lib/rules/tripleSlashReferenceValidity.js

@@ -1,54 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/tripleSlashReferenceValidity.ts
-const referenceMatcher = /^\/\/\/\s*<\s*reference(?:\s+([\w-]+\s*=\s*"[^"]*"|[\w-]+\s*=\s*'[^']*'|[^\s/>]+))?\s*\/>/i;
-const validDirectives = new Set([
-	"lib",
-	"no-default-lib",
-	"path",
-	"types"
-]);
-var tripleSlashReferenceValidity_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports invalid triple-slash reference directives.",
-		id: "tripleSlashReferenceValidity",
-		presets: ["logical"]
-	},
-	messages: { invalidDirective: {
-		primary: "Invalid triple-slash reference directive format.",
-		secondary: ["Only path, types, lib, and no-default-lib directives are valid TypeScript reference types.", "Triple-slash directives with incorrect reference types don't have any affect on types."],
-		suggestions: ["Use /// <reference types=\"...\" />, /// <reference path=\"...\" />, /// <reference lib=\"...\" />, or /// <reference no-default-lib=\"true\" />."]
-	} },
-	setup(context) {
-		function checkLine(line, position) {
-			const trimmed = line.trimStart();
-			if (!trimmed.startsWith("///")) return;
-			const referenceMatch = referenceMatcher.exec(trimmed);
-			if (!referenceMatch) return;
-			const attributes = referenceMatch[1]?.trim();
-			if (attributes) {
-				const attributeMatch = /^([\w-]+)\s*=\s*["'][^"']*["']$/.exec(attributes);
-				if (attributeMatch && validDirectives.has(attributeMatch[1].toLowerCase())) return;
-			}
-			context.report({
-				message: "invalidDirective",
-				range: {
-					begin: position + line.indexOf("///"),
-					end: position + line.length
-				}
-			});
-		}
-		return { visitors: { SourceFile(node) {
-			const lines = node.getFullText().split("\n");
-			let position = 0;
-			for (const line of lines) {
-				checkLine(line, position);
-				position += line.length + 1;
-			}
-		} } };
-	}
-});
-//#endregion
-export { tripleSlashReferenceValidity_default as default };
-
-//# sourceMappingURL=tripleSlashReferenceValidity.js.map

package/lib/rules/tripleSlashReferences.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports triple-slash reference directives.";
-    readonly id: "tripleSlashReferences";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noTripleSlashReference", undefined>;
-export default _default;
-//# sourceMappingURL=tripleSlashReferences.d.ts.map

package/lib/rules/tripleSlashReferences.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/tripleSlashReferences.ts
-var tripleSlashReferences_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports triple-slash reference directives.",
-		id: "tripleSlashReferences",
-		presets: ["logical"]
-	},
-	messages: { noTripleSlashReference: {
-		primary: "Prefer ECMAScript modules and/or TSConfig settings over legacy triple-slash directives.",
-		secondary: ["ECMAScript module imports are the modern way to declare dependencies.", "Triple-slash references are only needed in specific legacy scenarios."],
-		suggestions: ["Use ECMAScript module imports instead.", "Configure tsconfig.json to include type definitions."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile(node) {
-			for (const reference of [
-				...node.referencedFiles,
-				...node.typeReferenceDirectives,
-				...node.libReferenceDirectives
-			]) context.report({
-				message: "noTripleSlashReference",
-				range: {
-					begin: reference.pos,
-					end: reference.end
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { tripleSlashReferences_default as default };
-
-//# sourceMappingURL=tripleSlashReferences.js.map

package/lib/rules/tsComments.d.ts

@@ -1,22 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports problematic TypeScript comment directives or requires descriptions after directives.";
-    readonly id: "tsComments";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "descriptionNotMatchPattern" | "directiveComment" | "preferExpectError" | "requiresDescription", {
-    allowTsExpectError: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"allow-with-description">, z.ZodObject<{
-        descriptionFormat: z.ZodString;
-    }, z.core.$strip>]>>;
-    allowTsIgnore: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"allow-with-description">, z.ZodObject<{
-        descriptionFormat: z.ZodString;
-    }, z.core.$strip>]>>;
-    allowTsNocheck: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"allow-with-description">, z.ZodObject<{
-        descriptionFormat: z.ZodString;
-    }, z.core.$strip>]>>;
-    minimumDescriptionLength: z.ZodDefault<z.ZodNumber>;
-}>;
-export default _default;
-//# sourceMappingURL=tsComments.d.ts.map

package/lib/rules/tsComments.js

@@ -1,130 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as tsutils from "ts-api-utils";
-import { z } from "zod/v4";
-//#region src/rules/tsComments.ts
-const directiveConfigSchema = z.union([
-	z.literal(true),
-	z.literal(false),
-	z.literal("allow-with-description"),
-	z.object({ descriptionFormat: z.string().describe("A regular expression that the description must match for it to be considered valid.") })
-]);
-const options = {
-	allowTsExpectError: directiveConfigSchema.default(false).describe("Whether to allow `@ts-expect-error` directives, and with which restrictions."),
-	allowTsIgnore: directiveConfigSchema.default(false).describe("Whether to allow `@ts-ignore` directives."),
-	allowTsNocheck: directiveConfigSchema.default(false).describe("Whether to allow `@ts-nocheck` directives."),
-	minimumDescriptionLength: z.number().int().min(0).default(10).describe("The minimum length required for a description when using 'allow-with-description'.")
-};
-const tsDirectiveRegex = /^(?:\/\/\/?|\/\*)\s*@ts-(ignore|expect-error|nocheck|check)(?<description>[\s:*].*)?/i;
-function createFixedComment(text, fromDirective, toDirective) {
-	return text.replace(new RegExp(`@ts-${fromDirective}`, "i"), `@ts-${toDirective}`);
-}
-const directiveConfigKeys = new Map([
-	["ts-expect-error", "allowTsExpectError"],
-	["ts-ignore", "allowTsIgnore"],
-	["ts-nocheck", "allowTsNocheck"]
-]);
-var tsComments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports problematic TypeScript comment directives or requires descriptions after directives.",
-		id: "tsComments",
-		presets: ["logical"]
-	},
-	messages: {
-		descriptionNotMatchPattern: {
-			primary: "The description for `{{ directive }}` does not match the preferred format: {{ format }}.",
-			secondary: ["This project requires comment directive descriptions to match the configured pattern.", "This helps maintain consistent and informative comments."],
-			suggestions: ["Update the description to match the required format.", "Check the rule configuration for the expected pattern."]
-		},
-		directiveComment: {
-			primary: "This project does not allow using `@{{ directive }}` to suppress compilation errors.",
-			secondary: ["Using TypeScript directive comments reduces the effectiveness of TypeScript's type system.", "Prefer fixing type errors or using targeted suppressions with descriptions."],
-			suggestions: ["Remove the directive and fix the underlying type error.", "If the suppression is necessary, add a description explaining why."]
-		},
-		preferExpectError: {
-			primary: "Prefer `@ts-expect-error` instead of `@ts-ignore`, as `@ts-expect-error` triggers type errors if it becomes unnecessary.",
-			secondary: ["`@ts-expect-error` will report if the next line has no error.", "This helps identify stale suppressions when errors are fixed."],
-			suggestions: ["Replace `@ts-ignore` with `@ts-expect-error`."]
-		},
-		requiresDescription: {
-			primary: "`@{{ directive }}` should include a description of at least {{ minimum }} characters.",
-			secondary: ["A description helps explain why the suppression is necessary.", "This improves code maintainability and documentation."],
-			suggestions: ["Add a description explaining why this suppression is needed."]
-		}
-	},
-	options,
-	setup(context) {
-		return { visitors: { SourceFile(node, { options }) {
-			function reportCommentDirective(comment, directive, data, messageDefault, messageIgnore = messageDefault) {
-				const range = {
-					begin: comment.pos,
-					end: comment.end
-				};
-				const [fix, message] = directive === "ts-ignore" ? [{
-					range,
-					text: createFixedComment(comment.text, "ignore", "expect-error")
-				}, messageIgnore] : [void 0, messageDefault];
-				context.report({
-					data,
-					fix,
-					message,
-					range
-				});
-			}
-			function getDirectiveOption(directive) {
-				const optionKey = directiveConfigKeys.get(directive);
-				if (!optionKey) return;
-				return options[optionKey];
-			}
-			const descriptionFormats = /* @__PURE__ */ new Map();
-			for (const directive of [
-				"ts-expect-error",
-				"ts-ignore",
-				"ts-nocheck"
-			]) {
-				const option = getDirectiveOption(directive);
-				if (typeof option === "object" && option.descriptionFormat) descriptionFormats.set(directive, new RegExp(option.descriptionFormat));
-			}
-			for (const comment of tsutils.iterateComments(node)) {
-				const match = tsDirectiveRegex.exec(comment.text);
-				if (!match) continue;
-				const directive = match[1].toLowerCase();
-				const description = (match.groups?.description ?? "").trim();
-				checkComment(comment, `ts-${directive}`, description);
-			}
-			function checkComment(comment, directive, description) {
-				const optionKey = directiveConfigKeys.get(directive);
-				if (!optionKey) return;
-				const config = options[optionKey];
-				switch (config) {
-					case "allow-with-description":
-						if (description.replace(/^[:\s*]+/, "").replace(/\s*\*\/$/, "").trim().length < options.minimumDescriptionLength) {
-							reportCommentDirective(comment, directive, {
-								directive,
-								minimum: options.minimumDescriptionLength
-							}, "requiresDescription");
-							return;
-						}
-						break;
-					case false: return;
-					case true:
-						reportCommentDirective(comment, directive, { directive }, "directiveComment", "preferExpectError");
-						return;
-					default:
-						if (typeof config === "object" && config.descriptionFormat) {
-							const format = descriptionFormats.get(directive);
-							if (format && !format.test(description)) reportCommentDirective(comment, directive, {
-								directive,
-								format: format.source
-							}, "descriptionNotMatchPattern");
-						}
-						break;
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { tsComments_default as default };
-
-//# sourceMappingURL=tsComments.js.map

package/lib/rules/tslintComments.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports TSLint disable/enable comments.";
-    readonly id: "tslintComments";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "tslintComment", undefined>;
-export default _default;
-//# sourceMappingURL=tslintComments.d.ts.map