@flint.fyi/ts 0.14.5 → 0.15.0

package/src/getFirstEnumValues.ts

@@ -1,59 +0,0 @@
-/**
- * Removes TypeScript enum values that alias earlier values.
- * @param original Any TypeScript enum with numeric values.
- * @returns A version of the enum with only the first occurrence of each value.
- * @example
- * Given the following enum:
- * ```ts
- * enum Example {
- *   A = 1,
- *   B = 2,
- *   C = A
- * }
- * ```
- * Its original value looks like:
- * ```ts
- * {
- *   1: 'C', // <-- Points to 'C', the alias of 'A'
- *   2: 'B',
- *   A: 1,
- *   B: 2,
- *   C: 1,
- * }
- * ```
- * Calling `getFirstEnumValues(Example)` would return:
- * ```ts
- * {
- *   1: 'A', // <-- Corrected to the original 'A'
- *   2: 'B',
- *   A: 1,
- *   B: 2,
- *   C: 1,
- * }
- * ```
- */
-export function getFirstEnumValues<
-	Keys extends string,
-	Values extends number,
-	Original extends Record<Keys | Values, Keys | Values>,
->(original: Original) {
-	const result = {} as Original;
-
-	for (const key in original) {
-		if (typeof original[key] !== "number") {
-			continue;
-		}
-
-		if (!(key in result)) {
-			result[key] = original[key];
-		}
-
-		if (!(original[key] in result)) {
-			// 🤷 enums are tricky to type.
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-			result[original[key]] = key as any;
-		}
-	}
-
-	return result;
-}

package/src/getTSNodeRange.ts

@@ -1,13 +0,0 @@
-import type * as ts from "typescript";
-
-import { CharacterReportRange } from "@flint.fyi/core";
-
-export function getTSNodeRange(
-	node: ts.Node,
-	sourceFile: ts.SourceFile,
-): CharacterReportRange {
-	return {
-		begin: node.getStart(sourceFile),
-		end: node.getEnd(),
-	};
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export { getTSNodeRange } from "./getTSNodeRange.js";
-export * from "./language.js";
-export { ts } from "./plugin.js";
-export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
-export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
-export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
-export { isGlobalVariable } from "./utils/isGlobalVariable.js";

package/src/language.ts

@@ -1,122 +0,0 @@
-import { createLanguage } from "@flint.fyi/core";
-import { createProjectService } from "@typescript-eslint/project-service";
-import {
-	createFSBackedSystem,
-	createVirtualTypeScriptEnvironment,
-} from "@typescript/vfs";
-import { CachedFactory } from "cached-factory";
-import { debugForFile } from "debug-for-file";
-import path from "node:path";
-import * as ts from "typescript";
-
-import { createTypeScriptFileFromProgram } from "./createTypeScriptFileFromProgram.js";
-import { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
-import { TSNodesByName } from "./nodes.js";
-import { prepareTypeScriptFile } from "./prepareTypeScriptFile.js";
-
-const log = debugForFile(import.meta.filename);
-
-const projectRoot = path.join(import.meta.dirname, "../..");
-
-export interface TypeScriptServices {
-	program: ts.Program;
-	sourceFile: ts.SourceFile;
-	typeChecker: ts.TypeChecker;
-}
-
-export const typescriptLanguage = createLanguage<
-	TSNodesByName,
-	TypeScriptServices
->({
-	about: {
-		name: "TypeScript",
-	},
-	prepare: () => {
-		const { service } = createProjectService();
-		const seenPrograms = new Set<ts.Program>();
-
-		const environments = new CachedFactory((filePathAbsolute: string) => {
-			const system = createFSBackedSystem(
-				new Map([[filePathAbsolute, "// ..."]]),
-				projectRoot,
-				ts,
-			);
-
-			return createVirtualTypeScriptEnvironment(
-				system,
-				[filePathAbsolute],
-				ts,
-				{
-					skipLibCheck: true,
-					target: ts.ScriptTarget.ESNext,
-				},
-			);
-		});
-
-		const servicePrograms = new CachedFactory((filePathAbsolute: string) => {
-			log("Opening client file:", filePathAbsolute);
-			service.openClientFile(filePathAbsolute);
-
-			log("Retrieving client services:", filePathAbsolute);
-			const scriptInfo = service.getScriptInfo(filePathAbsolute);
-			if (!scriptInfo) {
-				throw new Error(
-					`Could not find script info for file: ${filePathAbsolute}`,
-				);
-			}
-
-			const defaultProject = service.getDefaultProjectForFile(
-				scriptInfo.fileName,
-				true,
-			);
-			if (!defaultProject) {
-				throw new Error(
-					`Could not find default project for file: ${filePathAbsolute}`,
-				);
-			}
-
-			const program = defaultProject.getLanguageService(true).getProgram();
-			if (!program) {
-				throw new Error(
-					`Could not retrieve program for file: ${filePathAbsolute}`,
-				);
-			}
-
-			return program;
-		});
-
-		return {
-			prepareFromDisk: (filePathAbsolute) => {
-				const program = servicePrograms.get(filePathAbsolute);
-
-				seenPrograms.add(program);
-
-				const { languageFile, sourceFile } =
-					createTypeScriptFileFromProjectService(
-						filePathAbsolute,
-						program,
-						service,
-					);
-
-				return prepareTypeScriptFile(languageFile, sourceFile);
-			},
-			prepareFromVirtual: (filePathAbsolute, sourceText) => {
-				const environment = environments.get(filePathAbsolute);
-				environment.updateFile(filePathAbsolute, sourceText);
-				/* eslint-disable @typescript-eslint/no-non-null-assertion */
-				const sourceFile = environment.getSourceFile(filePathAbsolute)!;
-				const program = environment.languageService.getProgram()!;
-				/* eslint-enable @typescript-eslint/no-non-null-assertion */
-
-				seenPrograms.add(program);
-
-				const languageFile = createTypeScriptFileFromProgram(
-					program,
-					sourceFile,
-				);
-
-				return prepareTypeScriptFile(languageFile, sourceFile);
-			},
-		};
-	},
-});

package/src/nodes.ts

@@ -1,146 +0,0 @@
-import type * as ts from "typescript";
-
-// TODO: Surely there's a better way to do this...
-// ...but I haven't checked how to do it without slow type operations.
-
-export interface TSNodesByName {
-	ArrayBindingPattern: ts.ArrayBindingPattern;
-	ArrayLiteralExpression: ts.ArrayLiteralExpression;
-	ArrowFunction: ts.ArrowFunction;
-	AsExpression: ts.AsExpression;
-	AwaitExpression: ts.AwaitExpression;
-	BigIntLiteral: ts.BigIntLiteral;
-	BinaryExpression: ts.BinaryExpression;
-	BindingElement: ts.BindingElement;
-	Block: ts.Block;
-	BreakStatement: ts.BreakStatement;
-	Bundle: ts.Bundle;
-	CallExpression: ts.CallExpression;
-	CaseBlock: ts.CaseBlock;
-	CaseClause: ts.CaseClause;
-	CatchClause: ts.CatchClause;
-	ClassDeclaration: ts.ClassDeclaration;
-	ClassExpression: ts.ClassExpression;
-	ClassStaticBlockDeclaration: ts.ClassStaticBlockDeclaration;
-	CommaListExpression: ts.CommaListExpression;
-	ComputedPropertyName: ts.ComputedPropertyName;
-	ConditionalExpression: ts.ConditionalExpression;
-	ConditionalType: ts.ConditionalType;
-	Constructor: ts.ConstructorDeclaration;
-	ContinueStatement: ts.ContinueStatement;
-	DebuggerStatement: ts.DebuggerStatement;
-	Decorator: ts.Decorator;
-	DefaultClause: ts.DefaultClause;
-	DeleteExpression: ts.DeleteExpression;
-	DoStatement: ts.DoStatement;
-	ElementAccessExpression: ts.ElementAccessExpression;
-	EmptyStatement: ts.EmptyStatement;
-	EnumDeclaration: ts.EnumDeclaration;
-	EnumMember: ts.EnumMember;
-	ExportAssignment: ts.ExportAssignment;
-	ExportDeclaration: ts.ExportDeclaration;
-	ExportSpecifier: ts.ExportSpecifier;
-	ExpressionStatement: ts.ExpressionStatement;
-	ExpressionWithTypeArguments: ts.ExpressionWithTypeArguments;
-	ExternalModuleReference: ts.ExternalModuleReference;
-	ForInStatement: ts.ForInStatement;
-	ForOfStatement: ts.ForOfStatement;
-	ForStatement: ts.ForStatement;
-	FunctionDeclaration: ts.FunctionDeclaration;
-	FunctionExpression: ts.FunctionExpression;
-	HeritageClause: ts.HeritageClause;
-	Identifier: ts.Identifier;
-	IfStatement: ts.IfStatement;
-	ImportAttribute: ts.ImportAttribute;
-	ImportAttributes: ts.ImportAttributes;
-	ImportClause: ts.ImportClause;
-	ImportDeclaration: ts.ImportDeclaration;
-	ImportEqualsDeclaration: ts.ImportEqualsDeclaration;
-	ImportSpecifier: ts.ImportSpecifier;
-	IndexedAccessType: ts.IndexedAccessType;
-	InterfaceDeclaration: ts.InterfaceDeclaration;
-	IntersectionType: ts.IntersectionType;
-	JsxAttribute: ts.JsxAttribute;
-	JsxAttributes: ts.JsxAttributes;
-	JsxClosingElement: ts.JsxClosingElement;
-	JsxClosingFragment: ts.JsxClosingFragment;
-	JsxElement: ts.JsxElement;
-	JsxExpression: ts.JsxExpression;
-	JsxFragment: ts.JsxFragment;
-	JsxNamespacedName: ts.JsxNamespacedName;
-	JsxOpeningElement: ts.JsxOpeningElement;
-	JsxOpeningFragment: ts.JsxOpeningFragment;
-	JsxSelfClosingElement: ts.JsxSelfClosingElement;
-	JsxSpreadAttribute: ts.JsxSpreadAttribute;
-	JsxText: ts.JsxText;
-	LabeledStatement: ts.LabeledStatement;
-	LiteralType: ts.LiteralType;
-	MappedTypeNode: ts.MappedTypeNode;
-	MetaProperty: ts.MetaProperty;
-	MethodDeclaration: ts.MethodDeclaration;
-	MethodSignature: ts.MethodSignature;
-	MissingDeclaration: ts.MissingDeclaration;
-	ModuleBlock: ts.ModuleBlock;
-	ModuleDeclaration: ts.ModuleDeclaration;
-	NamedExports: ts.NamedExports;
-	NamedImports: ts.NamedImports;
-	NamedTupleMember: ts.NamedTupleMember;
-	NamespaceExport: ts.NamespaceExport;
-	NamespaceExportDeclaration: ts.NamespaceExportDeclaration;
-	NamespaceImport: ts.NamespaceImport;
-	NewExpression: ts.NewExpression;
-	NonNullExpression: ts.NonNullExpression;
-	NoSubstitutionTemplateLiteral: ts.NoSubstitutionTemplateLiteral;
-	NotEmittedStatement: ts.NotEmittedStatement;
-	NotEmittedTypeElement: ts.NotEmittedTypeElement;
-	NumericLiteral: ts.NumericLiteral;
-	ObjectBindingPattern: ts.ObjectBindingPattern;
-	ObjectLiteralExpression: ts.ObjectLiteralExpression;
-	OmittedExpression: ts.OmittedExpression;
-	ParenthesizedExpression: ts.ParenthesizedExpression;
-	PartiallyEmittedExpression: ts.PartiallyEmittedExpression;
-	PostfixUnaryExpression: ts.PostfixUnaryExpression;
-	PrefixUnaryExpression: ts.PrefixUnaryExpression;
-	PrivateIdentifier: ts.PrivateIdentifier;
-	PropertyAccessExpression: ts.PropertyAccessExpression;
-	PropertyAssignment: ts.PropertyAssignment;
-	PropertyDeclaration: ts.PropertyDeclaration;
-	PropertySignature: ts.PropertySignature;
-	QualifiedName: ts.QualifiedName;
-	RegularExpressionLiteral: ts.RegularExpressionLiteral;
-	ReturnStatement: ts.ReturnStatement;
-	SatisfiesExpression: ts.SatisfiesExpression;
-	SemicolonClassElement: ts.SemicolonClassElement;
-	ShorthandPropertyAssignment: ts.ShorthandPropertyAssignment;
-	SourceFile: ts.SourceFile;
-	SpreadAssignment: ts.SpreadAssignment;
-	SpreadElement: ts.SpreadElement;
-	StringLiteral: ts.StringLiteral;
-	SwitchStatement: ts.SwitchStatement;
-	SyntaxList: ts.SyntaxList;
-	SyntheticExpression: ts.SyntheticExpression;
-	TaggedTemplateExpression: ts.TaggedTemplateExpression;
-	TemplateExpression: ts.TemplateExpression;
-	TemplateHead: ts.TemplateHead;
-	TemplateLiteralType: ts.TemplateLiteralType;
-	TemplateLiteralTypeSpan: ts.TemplateLiteralTypeSpan;
-	TemplateMiddle: ts.TemplateMiddle;
-	TemplateSpan: ts.TemplateSpan;
-	TemplateTail: ts.TemplateTail;
-	ThrowStatement: ts.ThrowStatement;
-	TryStatement: ts.TryStatement;
-	TupleType: ts.TupleType;
-	TypeAliasDeclaration: ts.TypeAliasDeclaration;
-	TypeOfExpression: ts.TypeOfExpression;
-	TypeParameter: ts.TypeParameter;
-	TypePredicate: ts.TypePredicate;
-	TypeReference: ts.TypeReference;
-	UnionType: ts.UnionType;
-	VariableDeclaration: ts.VariableDeclaration;
-	VariableDeclarationList: ts.VariableDeclarationList;
-	VariableStatement: ts.VariableStatement;
-	VoidExpression: ts.VoidExpression;
-	WhileStatement: ts.WhileStatement;
-	WithStatement: ts.WithStatement;
-	YieldExpression: ts.YieldExpression;
-}

package/src/normalizeRange.ts

@@ -1,30 +0,0 @@
-import type * as ts from "typescript";
-
-import {
-	CharacterReportRange,
-	NormalizedReportRangeObject,
-} from "@flint.fyi/core";
-
-export function normalizeRange(
-	original: CharacterReportRange,
-	sourceFile: ts.SourceFile,
-): NormalizedReportRangeObject {
-	const onCharacters = isNode(original)
-		? { begin: original.getStart(), end: original.getEnd() }
-		: original;
-
-	return {
-		begin: normalizeRangePosition(onCharacters.begin, sourceFile),
-		end: normalizeRangePosition(onCharacters.end, sourceFile),
-	};
-}
-
-function isNode(value: unknown): value is ts.Node {
-	return typeof value === "object" && value !== null && "kind" in value;
-}
-
-function normalizeRangePosition(raw: number, sourceFile: ts.SourceFile) {
-	const { character, line } = sourceFile.getLineAndCharacterOfPosition(raw);
-
-	return { column: character, line, raw };
-}

package/src/plugin.ts

@@ -1,111 +0,0 @@
-import { createPlugin } from "@flint.fyi/core";
-
-import anyReturns from "./rules/anyReturns.js";
-import asyncPromiseExecutors from "./rules/asyncPromiseExecutors.js";
-import caseDeclarations from "./rules/caseDeclarations.js";
-import caseDuplicates from "./rules/caseDuplicates.js";
-import chainedAssignments from "./rules/chainedAssignments.js";
-import classAssignments from "./rules/classAssignments.js";
-import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
-import constantAssignments from "./rules/constantAssignments.js";
-import constructorReturns from "./rules/constructorReturns.js";
-import debuggerStatements from "./rules/debuggerStatements.js";
-import defaultCaseLast from "./rules/defaultCaseLast.js";
-import duplicateArguments from "./rules/duplicateArguments.js";
-import elseIfDuplicates from "./rules/elseIfDuplicates.js";
-import emptyBlocks from "./rules/emptyBlocks.js";
-import emptyDestructures from "./rules/emptyDestructures.js";
-import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
-import exceptionAssignments from "./rules/exceptionAssignments.js";
-import forDirections from "./rules/forDirections.js";
-import forInArrays from "./rules/forInArrays.js";
-import functionAssignments from "./rules/functionAssignments.js";
-import functionNewCalls from "./rules/functionNewCalls.js";
-import generatorFunctionYields from "./rules/generatorFunctionYields.js";
-import globalAssignments from "./rules/globalAssignments.js";
-import globalObjectCalls from "./rules/globalObjectCalls.js";
-import namespaceDeclarations from "./rules/namespaceDeclarations.js";
-import negativeZeroComparisons from "./rules/negativeZeroComparisons.js";
-import newExpressions from "./rules/newExpressions.js";
-import newNativeNonConstructors from "./rules/newNativeNonConstructors.js";
-import nonOctalDecimalEscapes from "./rules/nonOctalDecimalEscapes.js";
-import numericLiteralParsing from "./rules/numericLiteralParsing.js";
-import objectProto from "./rules/objectProto.js";
-import octalEscapes from "./rules/octalEscapes.js";
-import octalNumbers from "./rules/octalNumbers.js";
-import returnAssignments from "./rules/returnAssignments.js";
-import selfAssignments from "./rules/selfAssignments.js";
-import selfComparisons from "./rules/selfComparisons.js";
-import sequences from "./rules/sequences.js";
-import shadowedRestrictedNames from "./rules/shadowedRestrictedNames.js";
-import sparseArrays from "./rules/sparseArrays.js";
-import symbolDescriptions from "./rules/symbolDescriptions.js";
-import typeofComparisons from "./rules/typeofComparisons.js";
-import unassignedVariables from "./rules/unassignedVariables.js";
-import undefinedVariables from "./rules/undefinedVariables.js";
-import unicodeBOMs from "./rules/unicodeBOMs.js";
-import unnecessaryBlocks from "./rules/unnecessaryBlocks.js";
-import unnecessaryCatches from "./rules/unnecessaryCatches.js";
-import unnecessaryConcatenation from "./rules/unnecessaryConcatenation.js";
-import unsafeNegations from "./rules/unsafeNegations.js";
-import variableDeletions from "./rules/variableDeletions.js";
-import voidOperator from "./rules/voidOperator.js";
-
-export const ts = createPlugin({
-	files: {
-		all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
-	},
-	name: "ts",
-	rules: [
-		anyReturns,
-		asyncPromiseExecutors,
-		caseDeclarations,
-		caseDuplicates,
-		chainedAssignments,
-		classAssignments,
-		consecutiveNonNullAssertions,
-		constantAssignments,
-		constructorReturns,
-		debuggerStatements,
-		defaultCaseLast,
-		duplicateArguments,
-		elseIfDuplicates,
-		emptyBlocks,
-		emptyDestructures,
-		emptyStaticBlocks,
-		exceptionAssignments,
-		forDirections,
-		forInArrays,
-		functionAssignments,
-		functionNewCalls,
-		generatorFunctionYields,
-		globalAssignments,
-		globalObjectCalls,
-		namespaceDeclarations,
-		negativeZeroComparisons,
-		newExpressions,
-		newNativeNonConstructors,
-		nonOctalDecimalEscapes,
-		numericLiteralParsing,
-		objectProto,
-		octalEscapes,
-		octalNumbers,
-		returnAssignments,
-		selfAssignments,
-		selfComparisons,
-		sequences,
-		shadowedRestrictedNames,
-		sparseArrays,
-		symbolDescriptions,
-		typeofComparisons,
-		unassignedVariables,
-		undefinedVariables,
-		unicodeBOMs,
-		unnecessaryBlocks,
-		unnecessaryCatches,
-		unnecessaryConcatenation,
-		unsafeNegations,
-		variableDeletions,
-		voidOperator,
-	],
-});

package/src/prepareTypeScriptFile.ts

@@ -1,14 +0,0 @@
-import { LanguageFileDefinition } from "@flint.fyi/core";
-import ts from "typescript";
-
-import { parseDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
-
-export function prepareTypeScriptFile(
-	languageFile: LanguageFileDefinition,
-	sourceFile: ts.SourceFile,
-) {
-	return {
-		...parseDirectivesFromTypeScriptFile(sourceFile),
-		file: languageFile,
-	};
-}