@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/typeImports.js

@@ -1,281 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { forEachChild, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-import { z as z$1 } 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$1.enum(["inline-type-imports", "separate-type-imports"]).default("inline-type-imports"),
-		prefer: z$1.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 };

package/lib/rules/typeofComparisons.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports typeof expressions that compare impossible string literals.";
-    readonly id: "typeofComparisons";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidValue", undefined>;
-export default _default;

package/lib/rules/typeofComparisons.js

@@ -1,53 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticStringValue, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/typeofComparisons.ts
-const validTypeofValues = /* @__PURE__ */ new Set([
-	"bigint",
-	"boolean",
-	"function",
-	"number",
-	"object",
-	"string",
-	"symbol",
-	"undefined"
-]);
-function getTypeofOperand(node) {
-	return node.kind === SyntaxKind.TypeOfExpression && node.expression;
-}
-var typeofComparisons_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports typeof expressions that compare impossible string literals.",
-		id: "typeofComparisons",
-		presets: ["javascript"]
-	},
-	messages: { invalidValue: {
-		primary: "This string literal is not one that the typeof operator will ever produce.",
-		secondary: [
-			"The typeof operator returns one of a specific set of string values.",
-			"Comparing typeof to an invalid string is usually a typo and will never match.",
-			"The only valid values are: \"bigint\", \"boolean\", \"function\", \"number\", \"object\", \"string\", \"symbol\", and \"undefined\"."
-		],
-		suggestions: ["Check for typos and use one of the valid typeof return values."]
-	} },
-	setup(context) {
-		function checkComparison(node, sourceFile) {
-			const leftTypeofOperand = getTypeofOperand(node.left);
-			const rightTypeofOperand = getTypeofOperand(node.right);
-			let comparisonValue;
-			if (leftTypeofOperand) comparisonValue = node.right;
-			else if (rightTypeofOperand) comparisonValue = node.left;
-			else return;
-			const stringValue = getStaticStringValue(comparisonValue);
-			if (stringValue !== void 0 && !validTypeofValues.has(stringValue)) context.report({
-				message: "invalidValue",
-				range: getTSNodeRange(comparisonValue, sourceFile)
-			});
-		}
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (node.operatorToken.kind === SyntaxKind.EqualsEqualsToken || node.operatorToken.kind === SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken.kind === SyntaxKind.ExclamationEqualsToken || node.operatorToken.kind === SyntaxKind.ExclamationEqualsEqualsToken) checkComparison(node, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { typeofComparisons_default as default };

package/lib/rules/unassignedVariables.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noUnassigned", undefined>;
-export default _default;

package/lib/rules/unassignedVariables.js

@@ -1,32 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/unassignedVariables.ts
-var unassignedVariables_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports variables that are declared but never assigned a value.",
-		id: "unassignedVariables",
-		presets: ["javascript"]
-	},
-	messages: { noUnassigned: {
-		primary: "Variable '{{ name }}' is declared but never assigned a value.",
-		secondary: ["Declaring a variable without ever assigning it a value means it will always be `undefined`.", "This is often a mistake, such as forgetting to initialize the variable or assign to it later."],
-		suggestions: ["Assign a value to the variable, either at declaration or before it is used.", "If the variable is meant to be `undefined`, consider making that explicit for clarity."]
-	} },
-	setup(context) {
-		return { visitors: { VariableDeclaration: (node, { sourceFile }) => {
-			if (node.initializer || node.name.kind !== SyntaxKind.Identifier) return;
-			if (node.parent.kind === SyntaxKind.VariableDeclarationList && !!(node.parent.flags & ts.NodeFlags.Const)) return;
-			if (!getModifyingReferences(node.name, sourceFile).length) context.report({
-				data: { name: node.name.text },
-				message: "noUnassigned",
-				range: {
-					begin: node.name.getStart(sourceFile),
-					end: node.name.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { unassignedVariables_default as default };

package/lib/rules/undefinedTypeofChecks.d.ts

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

package/lib/rules/undefinedTypeofChecks.js

@@ -1,39 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/undefinedTypeofChecks.ts
-var undefinedTypeofChecks_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports typeof undefined checks.",
-		id: "undefinedTypeofChecks",
-		presets: ["stylistic"]
-	},
-	messages: { directComparison: {
-		primary: "This `typeof` comparison can be simplified to `=== undefined`.",
-		secondary: ["Checking whether a value is `undefined` can be done either with a `typeof` check or an equality comparison.", "Both amount to the same in modern code that does not override the global `undefined` value."],
-		suggestions: ["Replace with a direct `undefined` comparison."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression(node, { sourceFile }) {
-			const operator = node.operatorToken.kind;
-			if (operator !== SyntaxKind.EqualsEqualsEqualsToken && operator !== SyntaxKind.ExclamationEqualsEqualsToken && operator !== SyntaxKind.EqualsEqualsToken && operator !== SyntaxKind.ExclamationEqualsToken) return;
-			let typeofExpression;
-			if (node.left.kind === SyntaxKind.TypeOfExpression && node.right.kind === SyntaxKind.StringLiteral && node.right.text === "undefined") typeofExpression = node.left.expression;
-			else if (node.right.kind === SyntaxKind.TypeOfExpression && node.left.kind === SyntaxKind.StringLiteral && node.left.text === "undefined") typeofExpression = node.right.expression;
-			if (!typeofExpression) return;
-			const range = getTSNodeRange(node, sourceFile);
-			const expressionText = typeofExpression.getText(sourceFile);
-			const operatorText = node.operatorToken.getText(sourceFile);
-			context.report({
-				fix: {
-					range,
-					text: `${expressionText} ${operatorText} undefined`
-				},
-				message: "directComparison",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { undefinedTypeofChecks_default as default };

package/lib/rules/undefinedVariables.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using variables that are not defined.";
-    readonly id: "undefinedVariables";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "undefinedVariable", undefined>;
-export default _default;

package/lib/rules/undefinedVariables.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/undefinedVariables.ts
-var undefinedVariables_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using variables that are not defined.",
-		id: "undefinedVariables",
-		presets: ["javascript"]
-	},
-	messages: { undefinedVariable: {
-		primary: "Variable '{{ name }}' is used but was never defined.",
-		secondary: ["Variables must be declared before they can be used.", "Using undefined variables will cause a ReferenceError at runtime."],
-		suggestions: ["Declare the variable before using it, or check if the variable name is spelled correctly."]
-	} },
-	setup(context) {
-		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
-			if (node.parent.kind === SyntaxKind.VariableDeclaration && node.parent.name === node) return;
-			if (node.parent.kind === SyntaxKind.Parameter && node.parent.name === node) return;
-			if ((node.parent.kind === SyntaxKind.FunctionDeclaration || node.parent.kind === SyntaxKind.ClassDeclaration || node.parent.kind === SyntaxKind.InterfaceDeclaration || node.parent.kind === SyntaxKind.TypeAliasDeclaration || node.parent.kind === SyntaxKind.EnumDeclaration || node.parent.kind === SyntaxKind.ModuleDeclaration) && node.parent.name === node) return;
-			if (node.parent.kind === SyntaxKind.ImportSpecifier || node.parent.kind === SyntaxKind.ImportClause || node.parent.kind === SyntaxKind.NamespaceImport) return;
-			if (node.parent.kind === SyntaxKind.PropertyAccessExpression && node.parent.name === node) return;
-			if (node.parent.kind === SyntaxKind.PropertyAssignment && node.parent.name === node) return;
-			if (node.parent.kind === SyntaxKind.TypeOfExpression && node.parent.expression === node) return;
-			if (!typeChecker.getSymbolAtLocation(node)) context.report({
-				data: { name: node.text },
-				message: "undefinedVariable",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { undefinedVariables_default as default };

package/lib/rules/unicodeBOMs.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
-    readonly id: "unicodeBOMs";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noBOM", undefined>;
-export default _default;

package/lib/rules/unicodeBOMs.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/unicodeBOMs.ts
-var unicodeBOMs_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports files with Unicode Byte Order Marks (BOMs).",
-		id: "unicodeBOMs",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { noBOM: {
-		primary: "This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.",
-		secondary: ["The Unicode BOM is a special character (U+FEFF) that can appear at the start of a file to indicate its byte order and encoding.", "While it can be useful in some contexts, it does not improve tooling portability and is not generally helpful for editors."],
-		suggestions: ["Remove the BOM from the beginning of the file."]
-	} },
-	setup(context) {
-		return { visitors: { SourceFile: (node) => {
-			if (node.getFullText().charCodeAt(0) !== 65279) return {};
-			context.report({
-				message: "noBOM",
-				range: {
-					begin: 0,
-					end: 1
-				},
-				suggestions: [{
-					id: "removeBOM",
-					range: {
-						begin: 0,
-						end: 1
-					},
-					text: ""
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { unicodeBOMs_default as default };

package/lib/rules/unnecessaryBinds.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary `.bind()` calls.";
-    readonly id: "unnecessaryBinds";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryBinds" | "arrowBind", undefined>;
-export default _default;

package/lib/rules/unnecessaryBinds.js

@@ -1,76 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryBinds.ts
-function containsThis(node) {
-	if (node.kind === ts.SyntaxKind.ThisKeyword) return true;
-	if (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) return false;
-	let found = false;
-	node.forEachChild((child) => {
-		if (containsThis(child)) found = true;
-	});
-	return found;
-}
-function isStaticValue(node) {
-	if (ts.isParenthesizedExpression(node)) return isStaticValue(node.expression);
-	if (ts.isPrefixUnaryExpression(node)) return isStaticValue(node.operand);
-	if (ts.isIdentifier(node)) return true;
-	if (ts.isPropertyAccessExpression(node)) return isStaticValue(node.expression);
-	if (ts.isElementAccessExpression(node)) return isStaticValue(node.expression) && isStaticValue(node.argumentExpression);
-	return node.kind === ts.SyntaxKind.ThisKeyword || node.kind === ts.SyntaxKind.SuperKeyword || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || ts.isBigIntLiteral(node) || ts.isNumericLiteral(node) || ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || node.kind === ts.SyntaxKind.RegularExpressionLiteral;
-}
-function unwrapParentheses(node) {
-	while (ts.isParenthesizedExpression(node)) node = node.expression;
-	return node;
-}
-var unnecessaryBinds_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary `.bind()` calls.",
-		id: "unnecessaryBinds",
-		presets: ["logical"]
-	},
-	messages: {
-		arrowBind: {
-			primary: "`.bind()` has no effect on arrow functions.",
-			secondary: ["Arrow functions have lexical 'this' binding.", "Calling .bind() on an arrow function has no effect."],
-			suggestions: ["Remove the `.bind()` call.", "Change the arrow function to a `function` that uses `this`"]
-		},
-		unnecessaryBinds: {
-			primary: "This `.bind()` call is unnecessary because the function does not use `this`.",
-			secondary: ["This function does not use `this`.", "`.bind()`'s purpose is to bind `this`, so using it on this function doesn't change anything."],
-			suggestions: ["Remove the `.bind()` call.", "Change the function to use `this` if that was intended."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression(node, { sourceFile }) {
-			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "bind" || node.arguments.length !== 1) return;
-			const boundArgument = node.arguments[0];
-			const boundFunction = unwrapParentheses(node.expression.expression);
-			const fix = isStaticValue(boundArgument) ? {
-				range: getTSNodeRange(node, sourceFile),
-				text: node.expression.expression.getText(sourceFile)
-			} : void 0;
-			if (ts.isArrowFunction(boundFunction)) {
-				context.report({
-					fix,
-					message: "arrowBind",
-					range: {
-						begin: node.expression.name.getStart(sourceFile),
-						end: node.end
-					}
-				});
-				return;
-			}
-			if (ts.isFunctionExpression(boundFunction) && !containsThis(boundFunction.body)) context.report({
-				fix,
-				message: "unnecessaryBinds",
-				range: {
-					begin: node.expression.name.getStart(sourceFile),
-					end: node.end
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryBinds_default as default };

package/lib/rules/unnecessaryBlocks.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryBlock", undefined>;
-export default _default;