@flint.fyi/ts 0.18.1 → 0.19.1

package/lib/rules/typeImports.js

@@ -0,0 +1,284 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { forEachChild } from "./utils/forEachChild.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/typeImports.ts
+function containsDecorator(node) {
+	if (node.kind === SyntaxKind.Decorator) return true;
+	return forEachChild(node, containsDecorator) ?? false;
+}
+function formatWordList(words) {
+	if (words.length < 2) return words[0] ?? "";
+	const last = words.at(-1);
+	return `${words.slice(0, -1).join(", ")} and ${last}`;
+}
+function getImportSource(node, sourceFile) {
+	return ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : node.moduleSpecifier.getText(sourceFile);
+}
+function getImportSpecifiers(node) {
+	const importClause = node.importClause;
+	if (!importClause) return [];
+	const specifiers = [];
+	if (importClause.name) specifiers.push(importClause.name);
+	const namedBindings = importClause.namedBindings;
+	if (namedBindings) if (namedBindings.kind === ts.SyntaxKind.NamespaceImport) specifiers.push(namedBindings);
+	else specifiers.push(...namedBindings.elements);
+	return specifiers;
+}
+function getReferencedSymbol(typeChecker, node) {
+	const symbol = typeChecker.getSymbolAtLocation(node);
+	return symbol?.flags && (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? typeChecker.getAliasedSymbol(symbol) : symbol;
+}
+function getSpecifierLocal(specifier) {
+	return specifier.kind === SyntaxKind.Identifier ? specifier : specifier.name;
+}
+function getTypeImportFix(report, sourceFile, fixStyle) {
+	const node = report.node;
+	const importText = node.getText(sourceFile);
+	const importClause = node.importClause;
+	const namedBindings = importClause?.namedBindings;
+	const range = getTSNodeRange(node, sourceFile);
+	if (report.valueSpecifiers.length || report.unusedSpecifiers.length) {
+		if (!importClause || importClause.name || namedBindings?.kind !== ts.SyntaxKind.NamedImports) return;
+		const typeSpecifiers = new Set(report.typeSpecifiers);
+		const remainingSpecifiers = namedBindings.elements.filter((specifier) => !typeSpecifiers.has(specifier));
+		const typeText = report.typeSpecifiers.map((specifier) => specifier.getText(sourceFile)).join(", ");
+		const remainingText = remainingSpecifiers.map((specifier) => specifier.getText(sourceFile)).join(", ");
+		const moduleText = node.moduleSpecifier.getText(sourceFile);
+		return {
+			range,
+			text: `import type { ${typeText}} from ${moduleText};\nimport { ${remainingText} } from ${moduleText};`
+		};
+	}
+	if (fixStyle === "inline-type-imports" && importClause && !importClause.name && namedBindings?.kind === ts.SyntaxKind.NamedImports) {
+		const moduleText = node.moduleSpecifier.getText(sourceFile);
+		return {
+			range,
+			text: `import { ${namedBindings.elements.map((specifier) => specifier.isTypeOnly ? specifier.getText(sourceFile) : `type ${specifier.getText(sourceFile)}`).join(", ")} } from ${moduleText};`
+		};
+	}
+	return {
+		range,
+		text: importText.replace(/^import\b/, "import type")
+	};
+}
+function getTypeKeywordFixRange(node, sourceFile) {
+	const range = getTypeKeywordRange(node, sourceFile);
+	if (sourceFile.text[range.end] === " ") range.end += 1;
+	return range;
+}
+function getTypeKeywordRange(node, sourceFile) {
+	for (const child of node.getChildren(sourceFile)) if (child.kind === SyntaxKind.TypeKeyword) {
+		const range = getTSNodeRange(child, sourceFile);
+		if (node.kind === SyntaxKind.ImportSpecifier && sourceFile.text[range.end] === " ") range.end += 1;
+		return range;
+	}
+	return getTSNodeRange(node, sourceFile);
+}
+function isInImportDeclaration(node) {
+	let current = node;
+	while (current) {
+		if (current.kind === SyntaxKind.ImportDeclaration) return true;
+		current = current.parent;
+	}
+	return false;
+}
+function isInlineTypeSpecifier(specifier) {
+	return specifier.kind === SyntaxKind.ImportSpecifier && specifier.isTypeOnly;
+}
+function isOnlyTypeReference(node) {
+	if (isTypeQueryReference(node) || isTypeOnlyExportReference(node) || isPropertySignatureComputedReference(node)) return true;
+	let current;
+	let parent = node.parent;
+	while (parent) {
+		if (parent.kind === ts.SyntaxKind.HeritageClause) return parent.token === SyntaxKind.ImplementsKeyword;
+		if (ts.isTypeAliasDeclaration(parent) || ts.isInterfaceDeclaration(parent) || ts.isTypeParameterDeclaration(parent)) return true;
+		if (ts.isTypeNode(parent) && !ts.isExpressionWithTypeArguments(parent)) return true;
+		current = parent;
+		parent = current.parent;
+	}
+	return false;
+}
+function isPropertySignatureComputedReference(node) {
+	let child = node;
+	let parent = node.parent;
+	while (parent) switch (parent.kind) {
+		case SyntaxKind.PropertySignature: return parent.name === child;
+		case SyntaxKind.ComputedPropertyName:
+			if (parent.expression !== child) return false;
+			child = parent;
+			parent = parent.parent;
+			continue;
+		case SyntaxKind.PropertyAccessExpression:
+			if (parent.expression !== child) return false;
+			child = parent;
+			parent = parent.parent;
+			continue;
+		default: return false;
+	}
+	return false;
+}
+function isTypeImportDeclaration(node) {
+	return node.importClause?.phaseModifier === SyntaxKind.TypeKeyword;
+}
+function isTypeOnlyExportReference(node) {
+	const parent = node.parent;
+	if (parent.kind !== SyntaxKind.ExportSpecifier) return false;
+	const exportDeclaration = parent.parent.parent;
+	return parent.name === node && exportDeclaration.isTypeOnly;
+}
+function isTypeQueryReference(node) {
+	let child = node;
+	let parent = node.parent;
+	while (parent) switch (parent.kind) {
+		case SyntaxKind.TypeQuery: return true;
+		case SyntaxKind.QualifiedName:
+			if (parent.left !== child) return false;
+			child = parent;
+			parent = parent.parent;
+			continue;
+		default: return false;
+	}
+	return false;
+}
+var typeImports_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports imports that do not match the configured type import style.",
+		id: "typeImports",
+		presets: ["stylistic"]
+	},
+	messages: {
+		avoidImportType: {
+			primary: "Use a regular import instead of a type-only import.",
+			secondary: ["This configuration prefers regular imports over `import type` syntax."],
+			suggestions: ["Change this type-only import to a regular import."]
+		},
+		someImportsAreOnlyTypes: {
+			primary: "Imports {{ typeImports }} are only used as types.",
+			secondary: ["These imports are only used in type positions.", "Using 'import type' improves tree-shaking and makes intent clear."],
+			suggestions: ["Change these imports to use 'import type'."]
+		},
+		typeOverValue: {
+			primary: "All imports in this declaration are only used as types. Use 'import type'.",
+			secondary: ["This import is only used in type positions.", "Using 'import type' improves tree-shaking and makes intent clear."],
+			suggestions: ["Change this declaration to use 'import type'."]
+		}
+	},
+	options: {
+		fixStyle: z.enum(["inline-type-imports", "separate-type-imports"]).default("inline-type-imports"),
+		prefer: z.enum(["no-type-imports", "type-imports"]).default("type-imports")
+	},
+	setup(context) {
+		return { visitors: { SourceFile(node, { options, program, sourceFile, typeChecker }) {
+			if (options.prefer === "no-type-imports") {
+				for (const statement of node.statements) {
+					if (!ts.isImportDeclaration(statement) || !statement.importClause) continue;
+					if (isTypeImportDeclaration(statement)) {
+						context.report({
+							fix: {
+								range: getTypeKeywordFixRange(statement.importClause, sourceFile),
+								text: ""
+							},
+							message: "avoidImportType",
+							range: getTypeKeywordRange(statement.importClause, sourceFile)
+						});
+						continue;
+					}
+					for (const specifier of getImportSpecifiers(statement)) {
+						if (!isInlineTypeSpecifier(specifier)) continue;
+						context.report({
+							fix: {
+								range: getTypeKeywordFixRange(specifier, sourceFile),
+								text: ""
+							},
+							message: "avoidImportType",
+							range: getTypeKeywordRange(specifier, sourceFile)
+						});
+					}
+				}
+				return;
+			}
+			const compilerOptions = program.getCompilerOptions();
+			if (compilerOptions.experimentalDecorators && compilerOptions.emitDecoratorMetadata && containsDecorator(node)) return;
+			const sourceImportsMap = {};
+			const importedSpecifiers = [];
+			const references = /* @__PURE__ */ new Map();
+			for (const statement of node.statements) {
+				if (!ts.isImportDeclaration(statement) || !statement.importClause) continue;
+				const source = getImportSource(statement, sourceFile);
+				sourceImportsMap[source] ??= { reportValueImports: [] };
+				if (isTypeImportDeclaration(statement)) continue;
+				for (const specifier of getImportSpecifiers(statement)) {
+					if (isInlineTypeSpecifier(specifier)) continue;
+					const local = getSpecifierLocal(specifier);
+					const importedSpecifier = {
+						local,
+						specifier,
+						symbol: getReferencedSymbol(typeChecker, local)
+					};
+					importedSpecifiers.push(importedSpecifier);
+					references.set(importedSpecifier, []);
+				}
+			}
+			function collectReferences(node) {
+				if (ts.isIdentifier(node) && !isInImportDeclaration(node)) {
+					const symbol = getReferencedSymbol(typeChecker, node);
+					const importedSpecifier = importedSpecifiers.find((specifier) => specifier.local.text === node.text && (!specifier.symbol || specifier.symbol === symbol));
+					if (importedSpecifier) references.get(importedSpecifier)?.push(node);
+				}
+				forEachChild(node, collectReferences);
+			}
+			collectReferences(node);
+			for (const statement of node.statements) {
+				if (!ts.isImportDeclaration(statement) || !statement.importClause || isTypeImportDeclaration(statement)) continue;
+				const typeSpecifiers = [];
+				const valueSpecifiers = [];
+				const unusedSpecifiers = [];
+				for (const specifier of getImportSpecifiers(statement)) {
+					if (isInlineTypeSpecifier(specifier)) continue;
+					const importedSpecifier = importedSpecifiers.find(({ specifier: found }) => found === specifier);
+					const specifierReferences = importedSpecifier ? references.get(importedSpecifier) : void 0;
+					if (!specifierReferences?.length) unusedSpecifiers.push(specifier);
+					else if (specifierReferences.every(isOnlyTypeReference)) typeSpecifiers.push(specifier);
+					else valueSpecifiers.push(specifier);
+				}
+				if (typeSpecifiers.length) {
+					const sourceImports = sourceImportsMap[getImportSource(statement, sourceFile)];
+					if (!sourceImports) continue;
+					sourceImports.reportValueImports.push({
+						node: statement,
+						typeSpecifiers,
+						unusedSpecifiers,
+						valueSpecifiers
+					});
+				}
+			}
+			for (const sourceImports of Object.values(sourceImportsMap)) {
+				if (!sourceImports.reportValueImports.length) continue;
+				for (const report of sourceImports.reportValueImports) {
+					const fix = getTypeImportFix(report, sourceFile, options.fixStyle);
+					if (!report.valueSpecifiers.length && !report.unusedSpecifiers.length && !report.node.attributes?.elements.length) {
+						context.report({
+							fix,
+							message: "typeOverValue",
+							range: getTSNodeRange(report.node, sourceFile)
+						});
+						continue;
+					}
+					const importNames = report.typeSpecifiers.map((specifier) => `"${getSpecifierLocal(specifier).text}"`);
+					context.report({
+						data: { typeImports: formatWordList(importNames) },
+						fix,
+						message: "someImportsAreOnlyTypes",
+						range: getTSNodeRange(report.node, sourceFile)
+					});
+				}
+			}
+		} } };
+	}
+});
+//#endregion
+export { typeImports_default as default };
+
+//# sourceMappingURL=typeImports.js.map

package/lib/rules/typeofComparisons.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports typeof expressions that compare impossible string literals.";
     readonly id: "typeofComparisons";
-    readonly presets: ["javascript"];
+    readonly presets: readonly ["javascript"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "invalidValue", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "invalidValue", undefined>;
 export default _default;
 //# sourceMappingURL=typeofComparisons.d.ts.map

package/lib/rules/unassignedVariables.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports variables that are declared but never assigned a value.";
     readonly id: "unassignedVariables";
-    readonly presets: ["javascript"];
+    readonly presets: readonly ["javascript"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "noUnassigned", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "noUnassigned", undefined>;
 export default _default;
 //# sourceMappingURL=unassignedVariables.d.ts.map

package/lib/rules/undefinedTypeofChecks.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports typeof undefined checks.";
     readonly id: "undefinedTypeofChecks";
-    readonly presets: ["stylistic"];
+    readonly presets: readonly ["stylistic"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "directComparison", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "directComparison", undefined>;
 export default _default;
 //# sourceMappingURL=undefinedTypeofChecks.d.ts.map

package/lib/rules/undefinedVariables.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using variables that are not defined.";
     readonly id: "undefinedVariables";
-    readonly presets: ["javascript"];
+    readonly presets: readonly ["javascript"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "undefinedVariable", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "undefinedVariable", undefined>;
 export default _default;
 //# sourceMappingURL=undefinedVariables.d.ts.map

package/lib/rules/unicodeBOMs.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
     readonly id: "unicodeBOMs";
-    readonly presets: ["stylistic", "stylisticStrict"];
+    readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "noBOM", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "noBOM", undefined>;
 export default _default;
 //# sourceMappingURL=unicodeBOMs.d.ts.map

package/lib/rules/unnecessaryBinds.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary `.bind()` calls.";
     readonly id: "unnecessaryBinds";
-    readonly presets: ["logical"];
+    readonly presets: readonly ["logical"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessaryBinds" | "arrowBind", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessaryBinds" | "arrowBind", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryBinds.d.ts.map

package/lib/rules/unnecessaryBlocks.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports standalone block statements that don't create a meaningful scope.";
     readonly id: "unnecessaryBlocks";
-    readonly presets: ["stylistic", "stylisticStrict"];
+    readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessaryBlock", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessaryBlock", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryBlocks.d.ts.map

package/lib/rules/unnecessaryBooleanCasts.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary boolean casts.";
     readonly id: "unnecessaryBooleanCasts";
-    readonly presets: ["logical"];
+    readonly presets: readonly ["logical"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessary", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessary", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryBooleanCasts.d.ts.map

package/lib/rules/unnecessaryCatches.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
     readonly id: "unnecessaryCatches";
-    readonly presets: ["logical", "logicalStrict"];
+    readonly presets: readonly ["logical", "logicalStrict"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessaryCatch", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessaryCatch", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryCatches.d.ts.map

package/lib/rules/unnecessaryComparisons.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports comparisons that are always true, always false, or can be simplified.";
     readonly id: "unnecessaryComparisons";
-    readonly presets: ["logical", "logicalStrict"];
+    readonly presets: readonly ["logical", "logicalStrict"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "impossibleRange" | "ineffectiveCheck" | "redundantComparison" | "selfComparison", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "impossibleRange" | "ineffectiveCheck" | "redundantComparison" | "selfComparison", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryComparisons.d.ts.map

package/lib/rules/unnecessaryConcatenation.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports string concatenation using the + operator when both operands are string literals.";
     readonly id: "unnecessaryConcatenation";
-    readonly presets: ["stylistic", "stylisticStrict"];
+    readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessaryConcatenation", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessaryConcatenation", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryConcatenation.d.ts.map

package/lib/rules/unnecessaryEscapes.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary escape sequences in string literals and template strings.";
     readonly id: "unnecessaryEscapes";
-    readonly presets: ["stylistic"];
+    readonly presets: readonly ["stylistic"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessary", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessary", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryEscapes.d.ts.map

package/lib/rules/unnecessaryMathClamps.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.";
     readonly id: "unnecessaryMathClamps";
-    readonly presets: ["logical"];
+    readonly presets: readonly ["logical"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "constantArguments" | "incorrectClampOrder", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "constantArguments" | "incorrectClampOrder", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryMathClamps.d.ts.map

package/lib/rules/unnecessaryNumericFractions.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports numeric literals with unnecessary zero fractions or dangling dots.";
     readonly id: "unnecessaryNumericFractions";
-    readonly presets: ["stylistic"];
+    readonly presets: readonly ["stylistic"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "danglingDot" | "zeroFraction", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "danglingDot" | "zeroFraction", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryNumericFractions.d.ts.map

package/lib/rules/unnecessaryRenames.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Renames that don't change the identifier name are unnecessary.";
     readonly id: "unnecessaryRenames";
-    readonly presets: ["stylistic"];
+    readonly presets: readonly ["stylistic"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessaryRename", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessaryRename", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryRenames.d.ts.map

package/lib/rules/unnecessaryTernaries.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators";
     readonly id: "unnecessaryTernaries";
-    readonly presets: ["stylistic", "stylisticStrict"];
+    readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessaryBooleanTernary" | "unnecessaryLogicalTernary", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessaryBooleanTernary" | "unnecessaryLogicalTernary", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryTernaries.d.ts.map

package/lib/rules/unnecessaryUseStricts.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary \"use strict\" directives in ES modules and classes.";
     readonly id: "unnecessaryUseStricts";
-    readonly presets: ["logical"];
+    readonly presets: readonly ["logical"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "unnecessaryUseStrict", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "unnecessaryUseStrict", undefined>;
 export default _default;
 //# sourceMappingURL=unnecessaryUseStricts.d.ts.map

package/lib/rules/unsafeNegations.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
     readonly id: "unsafeNegations";
-    readonly presets: ["javascript"];
+    readonly presets: readonly ["javascript"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "preferNegatingRelation", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "preferNegatingRelation", undefined>;
 export default _default;
 //# sourceMappingURL=unsafeNegations.d.ts.map

package/lib/rules/utils/forEachChild.d.ts

@@ -0,0 +1,4 @@
+import type { AST } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+export declare const forEachChild: <T>(node: AST.AnyNode, cbNode: (node: AST.AnyNode) => T | undefined, cbNodes?: (nodes: ts.NodeArray<AST.AnyNode>) => T | undefined) => T | undefined;
+//# sourceMappingURL=forEachChild.d.ts.map

package/lib/rules/utils/forEachChild.js

@@ -0,0 +1,7 @@
+import ts from "typescript";
+//#region src/rules/utils/forEachChild.ts
+const forEachChild = ts.forEachChild;
+//#endregion
+export { forEachChild };
+
+//# sourceMappingURL=forEachChild.js.map

package/lib/rules/variableDeletions.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports attempting to delete variables with the delete operator.";
     readonly id: "variableDeletions";
-    readonly presets: ["javascript"];
+    readonly presets: readonly ["javascript"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "noDeleteVar", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "noDeleteVar", undefined>;
 export default _default;
 //# sourceMappingURL=variableDeletions.d.ts.map

package/lib/rules/voidOperator.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the void operator.";
     readonly id: "voidOperator";
-    readonly presets: ["stylistic", "stylisticStrict"];
+    readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "noVoid", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "noVoid", undefined>;
 export default _default;
 //# sourceMappingURL=voidOperator.d.ts.map

package/lib/rules/withStatements.d.ts

@@ -1,10 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using with statements";
     readonly id: "withStatements";
-    readonly presets: ["javascript"];
+    readonly presets: readonly ["javascript"];
 } & {
-    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
-    url: string;
-}, object, object, "withStatement", import("@flint.fyi/core").AnyOptionalSchema>;
+    readonly pluginId: string;
+    readonly url: string;
+}, "withStatement", undefined>;
 export default _default;
 //# sourceMappingURL=withStatements.d.ts.map