@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/nodes.d.ts

@@ -1,143 +0,0 @@
-import type * as ts from "typescript";
-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;
-}
-//# sourceMappingURL=nodes.d.ts.map

package/lib/nodes.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=nodes.js.map

package/lib/normalizeRange.d.ts

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

package/lib/normalizeRange.js

@@ -1,14 +0,0 @@
-import { getColumnAndLineOfPosition, } from "@flint.fyi/core";
-export function normalizeRange(original, sourceFile) {
-    const onCharacters = isNode(original)
-        ? { begin: original.getStart(), 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;
-}
-//# sourceMappingURL=normalizeRange.js.map

package/lib/prepareTypeScriptBasedLanguage.d.ts

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

package/lib/prepareTypeScriptBasedLanguage.js

@@ -1,59 +0,0 @@
-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 { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
-const projectRoot = path.join(import.meta.dirname, "../..");
-const log = debugForFile(import.meta.filename);
-export function prepareTypeScriptBasedLanguage() {
-    const { service } = createProjectService();
-    const seenPrograms = new Set();
-    const environments = new CachedFactory((filePathAbsolute) => {
-        const system = createFSBackedSystem(new Map([[filePathAbsolute, "// ..."]]), projectRoot, ts);
-        return createVirtualTypeScriptEnvironment(system, [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);
-            /* 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);
-            return {
-                program,
-                sourceFile,
-            };
-        },
-    };
-}
-//# sourceMappingURL=prepareTypeScriptBasedLanguage.js.map

package/lib/prepareTypeScriptFile.d.ts

@@ -1,12 +0,0 @@
-import { TypeScriptBasedLanguageFile } from "./prepareTypeScriptBasedLanguage.js";
-export declare function prepareTypeScriptFile(file: TypeScriptBasedLanguageFile): {
-    file: {
-        cache?: import("@flint.fyi/core").LanguageFileCacheImpacts;
-        getDiagnostics?(): import("@flint.fyi/core").LanguageDiagnostics;
-        runRule<OptionsSchema extends import("@flint.fyi/core").AnyOptionalSchema | undefined = import("@flint.fyi/core").AnyOptionalSchema | undefined>(rule: import("@flint.fyi/core").AnyRuleDefinition<OptionsSchema>, options: import("@flint.fyi/core").InferredObject<OptionsSchema>): import("@flint.fyi/utils").PromiseOrSync<import("@flint.fyi/core").NormalizedReport[]>;
-        [Symbol.dispose]?: (() => void) | undefined;
-    };
-    directives: import("@flint.fyi/core").CommentDirective[];
-    reports: import("@flint.fyi/core").FileReport[];
-};
-//# sourceMappingURL=prepareTypeScriptFile.d.ts.map

package/lib/prepareTypeScriptFile.js

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

package/lib/rules/anyReturns.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=anyReturns.test.d.ts.map