@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/thisAliases.js

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

package/lib/rules/thisBeforeSuper.d.ts

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

package/lib/rules/thisBeforeSuper.js

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

package/lib/rules/throwErrors.d.ts

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

package/lib/rules/throwErrors.js

@@ -1,59 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { declarationIncludesGlobal, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { TypeFlags } from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/throwErrors.ts
-function isBuiltinErrorType(type, program) {
-	const symbol = type.getSymbol();
-	if (symbol?.getName() !== "Error") return false;
-	return !!symbol.getDeclarations()?.some((declaration) => declarationIncludesGlobal(declaration, program));
-}
-function isErrorType(type, program) {
-	if (isBuiltinErrorType(type, program)) return true;
-	if (type.isUnion()) return type.types.every((t) => isErrorType(t, program));
-	if (type.isIntersection()) return type.types.some((t) => isErrorType(t, program));
-	const baseTypes = type.getBaseTypes();
-	if (baseTypes) {
-		for (const baseType of baseTypes) if (isErrorType(baseType, program)) 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, { program, sourceFile, typeChecker }) {
-			const type = getConstrainedTypeAtLocation(node.expression, typeChecker);
-			if (tsutils.isTypeFlagSet(type, TypeFlags.Any | TypeFlags.Unknown) || isErrorType(type, program)) return;
-			if (type.isUnion() ? type.types.every((t) => tsutils.isTypeFlagSet(t, TypeFlags.Undefined)) : tsutils.isTypeFlagSet(type, 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 };

package/lib/rules/topLevelAwaits.d.ts

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

package/lib/rules/topLevelAwaits.js

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

package/lib/rules/tripleSlashReferenceValidity.d.ts

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

package/lib/rules/tripleSlashReferenceValidity.js

@@ -1,52 +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 = /* @__PURE__ */ 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 };

package/lib/rules/tripleSlashReferences.d.ts

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

package/lib/rules/tripleSlashReferences.js

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

package/lib/rules/tsComments.d.ts

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

package/lib/rules/tsComments.js

@@ -1,128 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as tsutils from "ts-api-utils";
-import { z as z$1 } from "zod/v4";
-//#region src/rules/tsComments.ts
-const directiveConfigSchema = z$1.union([
-	z$1.literal(true),
-	z$1.literal(false),
-	z$1.literal("allow-with-description"),
-	z$1.object({ descriptionFormat: z$1.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$1.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 = /* @__PURE__ */ 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 };

package/lib/rules/tslintComments.d.ts

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

package/lib/rules/tslintComments.js

@@ -1,34 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/tslintComments.ts
-const tslintDirectiveRegex = /^\s*\/?tslint:(?:enable|disable)(?:-(?:line|next-line))?(?::|\s|$)/i;
-var tslintComments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports TSLint disable/enable comments.",
-		id: "tslintComments",
-		presets: ["logical"]
-	},
-	messages: { tslintComment: {
-		primary: "TSLint is deprecated and its comments are no longer necessary.",
-		secondary: ["TSLint has been replaced by other linters such as Flint.", "These comments no longer have any effect."],
-		suggestions: ["Remove the TSLint comment.", "Replace it with the equivalent Flint comment if needed."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile: (node) => {
-			const comments = tsutils.iterateComments(node);
-			for (const { end, pos, text } of comments) {
-				const commentContent = text.replace(/^\/\/\s*/, "").replace(/^\/\*\s*/, "").replace(/\s*\*\/$/, "");
-				if (tslintDirectiveRegex.test(commentContent)) context.report({
-					message: "tslintComment",
-					range: {
-						begin: pos,
-						end
-					}
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { tslintComments_default as default };

package/lib/rules/typeAssertionStyles.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports angle-bracket type assertions.";
-    readonly id: "typeAssertionStyles";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferAs", undefined>;
-export default _default;

package/lib/rules/typeAssertionStyles.js

@@ -1,30 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/typeAssertionStyles.ts
-function isConstAssertion(node, sourceFile) {
-	return node.type.kind === ts.SyntaxKind.TypeReference && node.type.typeName.kind === ts.SyntaxKind.Identifier && node.type.typeName.getText(sourceFile) === "const";
-}
-var typeAssertionStyles_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports angle-bracket type assertions.",
-		id: "typeAssertionStyles",
-		presets: ["stylistic"]
-	},
-	messages: { preferAs: {
-		primary: "Prefer `as` syntax for type assertions instead of legacy angle-brackets.",
-		secondary: ["Angle-bracket syntax is ambiguous with JSX.", "The 'as' syntax is clearer and works in all contexts."],
-		suggestions: ["Convert '<Type>value' to 'value as Type'."]
-	} },
-	setup(context) {
-		return { visitors: { TypeAssertionExpression(node, { sourceFile }) {
-			if (isConstAssertion(node, sourceFile)) return;
-			context.report({
-				message: "preferAs",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { typeAssertionStyles_default as default };

package/lib/rules/typeImports.d.ts

@@ -1,19 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports imports that do not match the configured type import style.";
-    readonly id: "typeImports";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "avoidImportType" | "someImportsAreOnlyTypes" | "typeOverValue", {
-    fixStyle: z.ZodDefault<z.ZodEnum<{
-        "inline-type-imports": "inline-type-imports";
-        "separate-type-imports": "separate-type-imports";
-    }>>;
-    prefer: z.ZodDefault<z.ZodEnum<{
-        "no-type-imports": "no-type-imports";
-        "type-imports": "type-imports";
-    }>>;
-}>;
-export default _default;