@flint.fyi/typescript-language 0.0.0

package/lib/lib/types/checker.d.ts

@@ -0,0 +1,23 @@
+import { CallExpression, Decorator, JsxOpeningElement, JsxSelfClosingElement, NewExpression, TaggedTemplateExpression } from "./ast.js";
+import ts, { Node, Signature, TupleTypeReference, Type, TypeChecker, TypeReference } from "typescript";
+
+//#region lib/types/checker.d.ts
+type Checker = CheckerOverrides & Omit<TypeChecker, keyof CheckerOverrides>;
+interface CheckerOverrides {
+  getResolvedSignature(node: CallExpression | Decorator | JsxOpeningElement | JsxSelfClosingElement | NewExpression | TaggedTemplateExpression | ts.CallLikeExpression): Signature | undefined;
+  /** Improve narrowing, borrow from typescript-eslint */
+  isArrayType(type: Type): type is TypeReference;
+  isTupleType(type: Type): type is TupleTypeReference;
+  /**
+   * TS internal api
+   * Return the type of the given property in the given type, or undefined if no such property exists
+   */
+  getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined;
+  /**
+   * TS internal api
+   */
+  getContextualTypeForArgumentAtIndex(node: Node, argIndex: number): Type;
+}
+//#endregion
+export { Checker };
+//# sourceMappingURL=checker.d.ts.map

package/lib/lib/utils/declarationIncludesGlobal.d.ts

@@ -0,0 +1 @@
+import ts from "typescript";

package/lib/lib/utils/getDeclarationsIfGlobal.d.ts

@@ -0,0 +1,2 @@
+import "../index.js";
+import "typescript";

package/lib/lib/utils/getModifyingReferences.d.ts

@@ -0,0 +1,3 @@
+import "../types/ast.js";
+import "../index.js";
+import ts from "typescript";

package/lib/lib/utils/hasSameTokens.d.ts

@@ -0,0 +1 @@
+import "../types/ast.js";

package/lib/lib/utils/isBuiltinArrayMethod.d.ts

@@ -0,0 +1,2 @@
+import "../index.js";
+import ts from "typescript";

package/lib/lib/utils/isFunction.d.ts

@@ -0,0 +1 @@
+import "../index.js";

package/lib/lib/utils/isGlobalDeclaration.d.ts

@@ -0,0 +1 @@
+import "../index.js";

package/lib/lib/utils/isGlobalDeclarationOfName.d.ts

@@ -0,0 +1,2 @@
+import "../index.js";
+import ts from "typescript";

package/lib/lib/utils/isGlobalVariable.d.ts

@@ -0,0 +1 @@
+import "../index.js";

package/lib/lib/utils/isInlineArrayCreation.d.ts

@@ -0,0 +1 @@
+import "typescript";

package/lib/lib/utils/unwrapParentParenthesizedExpressions.d.ts

@@ -0,0 +1 @@
+import "../types/ast.js";

package/lib/lib/utils/unwrapParenthesizedExpression.d.ts

@@ -0,0 +1 @@
+import "../types/ast.js";

package/lib/nodes.d.ts

@@ -0,0 +1,202 @@
+import { AnyKeyword, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntKeyword, BigIntLiteral, BinaryExpression, BindingElement, Block, BooleanKeyword, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, CommaListExpression, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DefaultClause, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, FalseLiteral, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportExpression, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, IntrinsicKeyword, JSDocAllType, JSDocFunctionType, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocMemberName, JSDocNamepathType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocParameterTag, JSDocPropertyTag, JSDocReturnTag, JSDocSignature, JSDocTemplateTag, JSDocText, JSDocTypeExpression, JSDocTypeLiteral, JSDocUnknownType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignature, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NeverKeyword, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NotEmittedStatement, NotEmittedTypeElement, NullLiteral, NumberKeyword, NumericLiteral, ObjectBindingPattern, ObjectKeyword, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignature, QualifiedName, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringKeyword, StringLiteral, SuperExpression, SwitchStatement, SymbolKeyword, SyntheticExpression, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisExpression, ThisTypeNode, ThrowStatement, TrueLiteral, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UndefinedKeyword, UnionTypeNode, UnknownKeyword, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, VoidKeyword, WhileStatement, WithStatement, YieldExpression } from "./types/ast.js";
+
+//#region src/nodes.d.ts
+interface TypeScriptNodesByName {
+  AnyKeyword: AnyKeyword;
+  ArrayBindingPattern: ArrayBindingPattern;
+  ArrayLiteralExpression: ArrayLiteralExpression;
+  ArrayType: ArrayTypeNode;
+  ArrowFunction: ArrowFunction;
+  AsExpression: AsExpression;
+  AwaitExpression: AwaitExpression;
+  BigIntKeyword: BigIntKeyword;
+  BigIntLiteral: BigIntLiteral;
+  BinaryExpression: BinaryExpression;
+  BindingElement: BindingElement;
+  Block: Block;
+  BooleanKeyword: BooleanKeyword;
+  BreakStatement: BreakStatement;
+  CallExpression: CallExpression;
+  CallSignature: CallSignatureDeclaration;
+  CaseBlock: CaseBlock;
+  CaseClause: CaseClause;
+  CatchClause: CatchClause;
+  ClassDeclaration: ClassDeclaration;
+  ClassExpression: ClassExpression;
+  ClassStaticBlockDeclaration: ClassStaticBlockDeclaration;
+  CommaListExpression: CommaListExpression;
+  ComputedPropertyName: ComputedPropertyName;
+  ConditionalExpression: ConditionalExpression;
+  ConditionalType: ConditionalTypeNode;
+  Constructor: ConstructorDeclaration;
+  ConstructorType: ConstructorTypeNode;
+  ConstructSignature: ConstructSignatureDeclaration;
+  ContinueStatement: ContinueStatement;
+  DebuggerStatement: DebuggerStatement;
+  Decorator: Decorator;
+  DefaultClause: DefaultClause;
+  DeleteExpression: DeleteExpression;
+  DoStatement: DoStatement;
+  ElementAccessExpression: ElementAccessExpression;
+  EmptyStatement: EmptyStatement;
+  EnumDeclaration: EnumDeclaration;
+  EnumMember: EnumMember;
+  ExportAssignment: ExportAssignment;
+  ExportDeclaration: ExportDeclaration;
+  ExportSpecifier: ExportSpecifier;
+  ExpressionStatement: ExpressionStatement;
+  ExpressionWithTypeArguments: ExpressionWithTypeArguments;
+  ExternalModuleReference: ExternalModuleReference;
+  FalseKeyword: FalseLiteral;
+  ForInStatement: ForInStatement;
+  ForOfStatement: ForOfStatement;
+  ForStatement: ForStatement;
+  FunctionDeclaration: FunctionDeclaration;
+  FunctionExpression: FunctionExpression;
+  FunctionType: FunctionTypeNode;
+  GetAccessor: GetAccessorDeclaration;
+  HeritageClause: HeritageClause;
+  Identifier: Identifier;
+  IfStatement: IfStatement;
+  ImportAttribute: ImportAttribute;
+  ImportAttributes: ImportAttributes;
+  ImportClause: ImportClause;
+  ImportDeclaration: ImportDeclaration;
+  ImportEqualsDeclaration: ImportEqualsDeclaration;
+  ImportKeyword: ImportExpression;
+  ImportSpecifier: ImportSpecifier;
+  ImportType: ImportTypeNode;
+  IndexedAccessType: IndexedAccessTypeNode;
+  IndexSignature: IndexSignatureDeclaration;
+  InferType: InferTypeNode;
+  InterfaceDeclaration: InterfaceDeclaration;
+  IntersectionType: IntersectionTypeNode;
+  IntrinsicKeyword: IntrinsicKeyword;
+  JSDocAllType: JSDocAllType;
+  JSDocFunctionType: JSDocFunctionType;
+  JSDocLink: JSDocLink;
+  JSDocLinkCode: JSDocLinkCode;
+  JSDocLinkPlain: JSDocLinkPlain;
+  JSDocMemberName: JSDocMemberName;
+  JSDocNamepathType: JSDocNamepathType;
+  JSDocNonNullableType: JSDocNonNullableType;
+  JSDocNullableType: JSDocNullableType;
+  JSDocOptionalType: JSDocOptionalType;
+  JSDocParameterTag: JSDocParameterTag;
+  JSDocPropertyTag: JSDocPropertyTag;
+  JSDocReturnTag: JSDocReturnTag;
+  JSDocSignature: JSDocSignature;
+  JSDocTemplateTag: JSDocTemplateTag;
+  JSDocText: JSDocText;
+  JSDocTypeExpression: JSDocTypeExpression;
+  JSDocTypeLiteral: JSDocTypeLiteral;
+  JSDocUnknownType: JSDocUnknownType;
+  JSDocVariadicType: JSDocVariadicType;
+  JsxAttribute: JsxAttribute;
+  JsxAttributes: JsxAttributes;
+  JsxClosingElement: JsxClosingElement;
+  JsxClosingFragment: JsxClosingFragment;
+  JsxElement: JsxElement;
+  JsxExpression: JsxExpression;
+  JsxFragment: JsxFragment;
+  JsxNamespacedName: JsxNamespacedName;
+  JsxOpeningElement: JsxOpeningElement;
+  JsxOpeningFragment: JsxOpeningFragment;
+  JsxSelfClosingElement: JsxSelfClosingElement;
+  JsxSpreadAttribute: JsxSpreadAttribute;
+  JsxText: JsxText;
+  LabeledStatement: LabeledStatement;
+  LiteralType: LiteralTypeNode;
+  MappedType: MappedTypeNode;
+  MetaProperty: MetaProperty;
+  MethodDeclaration: MethodDeclaration;
+  MethodSignature: MethodSignature;
+  MissingDeclaration: MissingDeclaration;
+  ModuleBlock: ModuleBlock;
+  ModuleDeclaration: ModuleDeclaration;
+  NamedExports: NamedExports;
+  NamedImports: NamedImports;
+  NamedTupleMember: NamedTupleMember;
+  NamespaceExport: NamespaceExport;
+  NamespaceExportDeclaration: NamespaceExportDeclaration;
+  NamespaceImport: NamespaceImport;
+  NeverKeyword: NeverKeyword;
+  NewExpression: NewExpression;
+  NonNullExpression: NonNullExpression;
+  NoSubstitutionTemplateLiteral: NoSubstitutionTemplateLiteral;
+  NotEmittedStatement: NotEmittedStatement;
+  NotEmittedTypeElement: NotEmittedTypeElement;
+  NullKeyword: NullLiteral;
+  NumberKeyword: NumberKeyword;
+  NumericLiteral: NumericLiteral;
+  ObjectBindingPattern: ObjectBindingPattern;
+  ObjectKeyword: ObjectKeyword;
+  ObjectLiteralExpression: ObjectLiteralExpression;
+  OmittedExpression: OmittedExpression;
+  OptionalType: OptionalTypeNode;
+  Parameter: ParameterDeclaration;
+  ParenthesizedExpression: ParenthesizedExpression;
+  ParenthesizedType: ParenthesizedTypeNode;
+  PartiallyEmittedExpression: PartiallyEmittedExpression;
+  PostfixUnaryExpression: PostfixUnaryExpression;
+  PrefixUnaryExpression: PrefixUnaryExpression;
+  PrivateIdentifier: PrivateIdentifier;
+  PropertyAccessExpression: PropertyAccessExpression;
+  PropertyAssignment: PropertyAssignment;
+  PropertyDeclaration: PropertyDeclaration;
+  PropertySignature: PropertySignature;
+  QualifiedName: QualifiedName;
+  RegularExpressionLiteral: RegularExpressionLiteral;
+  RestType: RestTypeNode;
+  ReturnStatement: ReturnStatement;
+  SatisfiesExpression: SatisfiesExpression;
+  SemicolonClassElement: SemicolonClassElement;
+  SetAccessor: SetAccessorDeclaration;
+  ShorthandPropertyAssignment: ShorthandPropertyAssignment;
+  SourceFile: SourceFile;
+  SpreadAssignment: SpreadAssignment;
+  SpreadElement: SpreadElement;
+  StringKeyword: StringKeyword;
+  StringLiteral: StringLiteral;
+  SuperKeyword: SuperExpression;
+  SwitchStatement: SwitchStatement;
+  SymbolKeyword: SymbolKeyword;
+  SyntheticExpression: SyntheticExpression;
+  TaggedTemplateExpression: TaggedTemplateExpression;
+  TemplateExpression: TemplateExpression;
+  TemplateHead: TemplateHead;
+  TemplateLiteralType: TemplateLiteralTypeNode;
+  TemplateLiteralTypeSpan: TemplateLiteralTypeSpan;
+  TemplateMiddle: TemplateMiddle;
+  TemplateSpan: TemplateSpan;
+  TemplateTail: TemplateTail;
+  ThisKeyword: ThisExpression;
+  ThisType: ThisTypeNode;
+  ThrowStatement: ThrowStatement;
+  TrueKeyword: TrueLiteral;
+  TryStatement: TryStatement;
+  TupleType: TupleTypeNode;
+  TypeAliasDeclaration: TypeAliasDeclaration;
+  TypeAssertionExpression: TypeAssertion;
+  TypeLiteral: TypeLiteralNode;
+  TypeOfExpression: TypeOfExpression;
+  TypeOperator: TypeOperatorNode;
+  TypeParameter: TypeParameterDeclaration;
+  TypePredicate: TypePredicateNode;
+  TypeQuery: TypeQueryNode;
+  TypeReference: TypeReferenceNode;
+  UndefinedKeyword: UndefinedKeyword;
+  UnionType: UnionTypeNode;
+  UnknownKeyword: UnknownKeyword;
+  VariableDeclaration: VariableDeclaration;
+  VariableDeclarationList: VariableDeclarationList;
+  VariableStatement: VariableStatement;
+  VoidExpression: VoidExpression;
+  VoidKeyword: VoidKeyword;
+  WhileStatement: WhileStatement;
+  WithStatement: WithStatement;
+  YieldExpression: YieldExpression;
+}
+//#endregion
+export { TypeScriptNodesByName };
+//# sourceMappingURL=nodes.d.ts.map

package/lib/normalizeRange.d.ts

@@ -0,0 +1,4 @@
+import { type CharacterReportRange, type NormalizedReportRangeObject } from "@flint.fyi/core";
+import type * as AST from "./types/ast.ts";
+export declare function normalizeRange(original: CharacterReportRange, sourceFile: AST.SourceFile): NormalizedReportRangeObject;
+//# sourceMappingURL=normalizeRange.d.ts.map

package/lib/normalizeRange.js

@@ -0,0 +1,20 @@
+import { getColumnAndLineOfPosition } from "@flint.fyi/core";
+
+//#region src/normalizeRange.ts
+function normalizeRange(original, sourceFile) {
+	const onCharacters = isNode(original) ? {
+		begin: original.getStart(sourceFile),
+		end: original.getEnd()
+	} : original;
+	return {
+		begin: getColumnAndLineOfPosition(sourceFile, onCharacters.begin),
+		end: getColumnAndLineOfPosition(sourceFile, onCharacters.end)
+	};
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && "kind" in value;
+}
+
+//#endregion
+export { normalizeRange };
+//# sourceMappingURL=normalizeRange.js.map

package/lib/prepareTypeScriptBasedLanguage.d.ts

@@ -0,0 +1,16 @@
+import { SourceFile } from "./types/ast.js";
+import ts from "typescript";
+
+//#region src/prepareTypeScriptBasedLanguage.d.ts
+interface TypeScriptBasedLanguageFile extends Partial<Disposable> {
+  program: ts.Program;
+  sourceFile: SourceFile;
+}
+interface TypeScriptBasedLanguageFileFactoryDefinition {
+  createFromDisk(filePathAbsolute: string): TypeScriptBasedLanguageFile;
+  createFromVirtual(filePathAbsolute: string, sourceText: string): TypeScriptBasedLanguageFile;
+}
+declare function prepareTypeScriptBasedLanguage(): TypeScriptBasedLanguageFileFactoryDefinition;
+//#endregion
+export { TypeScriptBasedLanguageFile, TypeScriptBasedLanguageFileFactoryDefinition, prepareTypeScriptBasedLanguage };
+//# sourceMappingURL=prepareTypeScriptBasedLanguage.d.ts.map

package/lib/prepareTypeScriptBasedLanguage.js

@@ -0,0 +1,55 @@
+import { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
+import ts from "typescript";
+import path from "node:path";
+import { createFSBackedSystem, createVirtualTypeScriptEnvironment } from "@typescript/vfs";
+import { createProjectService } from "@typescript-eslint/project-service";
+import { CachedFactory } from "cached-factory";
+import { debugForFile } from "debug-for-file";
+
+//#region src/prepareTypeScriptBasedLanguage.ts
+const projectRoot = path.join(import.meta.dirname, "../..");
+const log = debugForFile(import.meta.filename);
+function prepareTypeScriptBasedLanguage() {
+	const { service } = createProjectService();
+	const seenPrograms = /* @__PURE__ */ new Set();
+	const environments = new CachedFactory((filePathAbsolute) => {
+		return createVirtualTypeScriptEnvironment(createFSBackedSystem(new Map([[filePathAbsolute, "// ..."]]), projectRoot, ts), [filePathAbsolute], ts, {
+			skipLibCheck: true,
+			target: ts.ScriptTarget.ESNext
+		});
+	});
+	const servicePrograms = new CachedFactory((filePathAbsolute) => {
+		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 {
+		createFromDisk: (filePathAbsolute) => {
+			const program = servicePrograms.get(filePathAbsolute);
+			seenPrograms.add(program);
+			return createTypeScriptFileFromProjectService(filePathAbsolute, program, service);
+		},
+		createFromVirtual: (filePathAbsolute, sourceText) => {
+			const environment = environments.get(filePathAbsolute);
+			environment.updateFile(filePathAbsolute, sourceText);
+			const sourceFile = environment.getSourceFile(filePathAbsolute);
+			const program = environment.languageService.getProgram();
+			seenPrograms.add(program);
+			return {
+				program,
+				sourceFile
+			};
+		}
+	};
+}
+
+//#endregion
+export { prepareTypeScriptBasedLanguage };
+//# sourceMappingURL=prepareTypeScriptBasedLanguage.js.map

package/lib/prepareTypeScriptFile.d.ts

@@ -0,0 +1,14 @@
+import type { FileAboutData } from "@flint.fyi/core";
+import type { TypeScriptBasedLanguageFile } from "./prepareTypeScriptBasedLanguage.ts";
+export declare function prepareTypeScriptFile(data: FileAboutData, file: TypeScriptBasedLanguageFile): {
+    file: {
+        about: import("@flint.fyi/core").FileDiskData;
+        cache?: import("@flint.fyi/core").LanguageFileCacheImpacts;
+        getDiagnostics?(): import("@flint.fyi/core").LanguageDiagnostics;
+        runVisitors<OptionsSchema extends import("@flint.fyi/core").AnyOptionalSchema | undefined = import("@flint.fyi/core").AnyOptionalSchema | undefined>(options: import("@flint.fyi/core").InferredOutputObject<OptionsSchema>, runtime: import("@flint.fyi/core").RuleRuntime<import("./nodes.ts").TypeScriptNodesByName, import("./language.ts").TypeScriptFileServices>): void;
+        [Symbol.dispose]?: () => void;
+    };
+    directives: import("@flint.fyi/core").CommentDirective[];
+    reports: import("@flint.fyi/core").FileReport[];
+};
+//# sourceMappingURL=prepareTypeScriptFile.d.ts.map

package/lib/prepareTypeScriptFile.js

@@ -0,0 +1,18 @@
+import { createTypeScriptFileFromProgram } from "./createTypeScriptFileFromProgram.js";
+import { parseDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
+
+//#region src/prepareTypeScriptFile.ts
+function prepareTypeScriptFile(data, file) {
+	const { program, sourceFile, [Symbol.dispose]: onDispose } = file;
+	return {
+		...parseDirectivesFromTypeScriptFile(sourceFile),
+		file: {
+			...onDispose != null && { [Symbol.dispose]: onDispose },
+			...createTypeScriptFileFromProgram(data, program, sourceFile)
+		}
+	};
+}
+
+//#endregion
+export { prepareTypeScriptFile };
+//# sourceMappingURL=prepareTypeScriptFile.js.map