@flint.fyi/ts 0.13.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @flint/ts
+
+## 0.13.0
+
+### Minor Changes
+
+- 72ed00b: feat: split into a monorepo
+
+### Patch Changes
+
+- Updated dependencies [72ed00b]
+  - @flint/rule-tester@0.13.0
+  - @flint/core@0.13.0

package/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/lib/collectReferencedFilePaths.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function collectReferencedFilePaths(program: ts.Program, sourceFile: ts.SourceFile): string[];

package/lib/collectReferencedFilePaths.js

@@ -0,0 +1,21 @@
+import * as path from "node:path";
+import * as ts from "typescript";
+export function collectReferencedFilePaths(program, sourceFile) {
+    // TODO: Also handle inline import()s
+    // https://github.com/JoshuaKGoldberg/flint/issues/115
+    return sourceFile.statements
+        .filter(isImportDeclarationWithStringLiteral)
+        .map((statement) => {
+        const resolved = ts.resolveModuleName(statement.moduleSpecifier.text, sourceFile.fileName, program.getCompilerOptions(), 
+        // TODO: Eventually, the file system should be abstracted
+        // https://github.com/JoshuaKGoldberg/flint/issues/73
+        ts.sys);
+        return (resolved.resolvedModule?.isExternalLibraryImport === false &&
+            path.relative(process.cwd(), resolved.resolvedModule.resolvedFileName));
+    })
+        .filter((resolvedFileName) => resolvedFileName !== false);
+}
+function isImportDeclarationWithStringLiteral(statement) {
+    return (ts.isImportDeclaration(statement) &&
+        ts.isStringLiteral(statement.moduleSpecifier));
+}

package/lib/createTypeScriptFileFromProgram.d.ts

@@ -0,0 +1,3 @@
+import { LanguageFileDefinition } from "@flint.fyi/core";
+import * as ts from "typescript";
+export declare function createTypeScriptFileFromProgram(program: ts.Program, sourceFile: ts.SourceFile): LanguageFileDefinition;

package/lib/createTypeScriptFileFromProgram.js

@@ -0,0 +1,56 @@
+import * as ts from "typescript";
+import { collectReferencedFilePaths } from "./collectReferencedFilePaths.js";
+import { formatDiagnostic } from "./formatDiagnostic.js";
+import { normalizeRange } from "./normalizeRange.js";
+export function createTypeScriptFileFromProgram(program, sourceFile) {
+    return {
+        cache: {
+            dependencies: [
+                // TODO: Add support for multi-TSConfig workspaces.
+                // https://github.com/JoshuaKGoldberg/flint/issues/64 & more.
+                "tsconfig.json",
+                ...collectReferencedFilePaths(program, sourceFile),
+            ],
+        },
+        getDiagnostics() {
+            return ts
+                .getPreEmitDiagnostics(program, sourceFile)
+                .map((diagnostic) => ({
+                code: `TS${diagnostic.code}`,
+                text: formatDiagnostic({
+                    ...diagnostic,
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    length: diagnostic.length,
+                    message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+                    name: `TS${diagnostic.code}`,
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    start: diagnostic.start,
+                }),
+            }));
+        },
+        runRule(rule, options) {
+            const reports = [];
+            const context = {
+                report: (report) => {
+                    reports.push({
+                        ...report,
+                        message: rule.messages[report.message],
+                        range: normalizeRange(report.range, sourceFile),
+                    });
+                },
+                sourceFile,
+                typeChecker: program.getTypeChecker(),
+            };
+            const visitors = rule.setup(context, options);
+            if (!visitors) {
+                return reports;
+            }
+            const visit = (node) => {
+                visitors[ts.SyntaxKind[node.kind]]?.(node);
+                node.forEachChild(visit);
+            };
+            sourceFile.forEachChild(visit);
+            return reports;
+        },
+    };
+}

package/lib/createTypeScriptFileFromProjectService.d.ts

@@ -0,0 +1,3 @@
+import { LanguageFileDefinition } from "@flint.fyi/core";
+import * as ts from "typescript";
+export declare function createTypeScriptFileFromProjectService(filePathAbsolute: string, program: ts.Program, service: ts.server.ProjectService): LanguageFileDefinition;

package/lib/createTypeScriptFileFromProjectService.js

@@ -0,0 +1,17 @@
+import { debugForFile } from "debug-for-file";
+import { createTypeScriptFileFromProgram } from "./createTypeScriptFileFromProgram.js";
+const log = debugForFile(import.meta.filename);
+export function createTypeScriptFileFromProjectService(filePathAbsolute, program, service) {
+    const sourceFile = program.getSourceFile(filePathAbsolute);
+    if (!sourceFile) {
+        throw new Error(`Could not retrieve source file for: ${filePathAbsolute}`);
+    }
+    log("Retrieved source file and type checker for file %s:", filePathAbsolute);
+    const file = createTypeScriptFileFromProgram(program, sourceFile);
+    return {
+        ...file,
+        [Symbol.dispose]() {
+            service.closeClientFile(filePathAbsolute);
+        },
+    };
+}

package/lib/formatDiagnostic.d.ts

@@ -0,0 +1,10 @@
+import ts from "typescript";
+export interface RawDiagnostic {
+    file?: ts.SourceFile;
+    length: number;
+    message: string;
+    name: string;
+    relatedInformation?: ts.DiagnosticRelatedInformation[];
+    start: number;
+}
+export declare function formatDiagnostic(diagnostic: RawDiagnostic): string;

package/lib/formatDiagnostic.js

@@ -0,0 +1,121 @@
+// Adapted from: https://github.com/ArnaudBarre/tsl/blob/742a6f1a956705239f2149f856b1f572ade79919/src/formatDiagnostic.ts
+// ...which notes:
+// Adapted from: https://github.com/microsoft/TypeScript/blob/78c16795cdee70b9d9f0f248b6dbb6ba50994a59/src/compiler/program.ts#L680-L811
+// eslint-disable-next-line @eslint-community/eslint-comments/disable-enable-pair
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { flattenDiagnosticMessageText, getLineAndCharacterOfPosition, getPositionOfLineAndCharacter, } from "typescript";
+export function formatDiagnostic(diagnostic) {
+    let output = "";
+    if (diagnostic.file !== undefined) {
+        output += formatLocation(diagnostic.file, diagnostic.start);
+        output += " - ";
+    }
+    output += color(diagnostic.name, COLOR.Grey);
+    output += ": ";
+    output += diagnostic.message;
+    if (diagnostic.file !== undefined) {
+        output += "\n";
+        output += formatCodeSpan(diagnostic.file, diagnostic.start, diagnostic.length, "", COLOR.Red);
+    }
+    if (diagnostic.relatedInformation) {
+        output += "\n";
+        for (const { file, length, messageText, start, } of diagnostic.relatedInformation) {
+            const indent = "  ";
+            if (file) {
+                output += "\n";
+                output += " " + formatLocation(file, start);
+                output += formatCodeSpan(file, start, length, indent, COLOR.Cyan);
+            }
+            output += "\n";
+            output += indent + flattenDiagnosticMessageText(messageText, "\n");
+        }
+    }
+    return output;
+}
+function color(text, formatStyle) {
+    return formatStyle + text + resetEscapeSequence;
+}
+const gutterStyleSequence = "\u001b[7m";
+const ellipsis = "...";
+const gutterSeparator = " ";
+const resetEscapeSequence = "\u001b[0m";
+const COLOR = {
+    Blue: "\u001b[94m",
+    Cyan: "\u001b[96m",
+    Grey: "\u001b[90m",
+    Red: "\u001b[91m",
+    Yellow: "\u001b[93m",
+};
+function displayFilename(name) {
+    if (name.startsWith("./")) {
+        return name.slice(2);
+    }
+    return name.slice(process.cwd().length + 1);
+}
+function formatCodeSpan(file, start, length, indent, squiggleColor) {
+    const { character: firstLineChar, line: firstLine } = getLineAndCharacterOfPosition(file, start);
+    const { character: lastLineChar, line: lastLine } = getLineAndCharacterOfPosition(file, start + length);
+    const lastLineInFile = getLineAndCharacterOfPosition(file, file.text.length).line;
+    const hasMoreThanFiveLines = lastLine - firstLine >= 4;
+    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+    let gutterWidth = (lastLine + 1 + "").length;
+    if (hasMoreThanFiveLines) {
+        gutterWidth = Math.max(ellipsis.length, gutterWidth);
+    }
+    let context = "";
+    for (let i = firstLine; i <= lastLine; i++) {
+        context += "\n";
+        if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {
+            context +=
+                indent +
+                    color(ellipsis.padStart(gutterWidth), gutterStyleSequence) +
+                    gutterSeparator +
+                    "\n";
+            i = lastLine - 1;
+        }
+        const lineStart = getPositionOfLineAndCharacter(file, i, 0);
+        const lineEnd = i < lastLineInFile
+            ? getPositionOfLineAndCharacter(file, i + 1, 0)
+            : file.text.length;
+        let lineContent = file.text.slice(lineStart, lineEnd);
+        lineContent = lineContent.trimEnd();
+        lineContent = lineContent.replace(/\t/g, " ");
+        context +=
+            indent +
+                // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+                color((i + 1 + "").padStart(gutterWidth), gutterStyleSequence) +
+                gutterSeparator;
+        context += lineContent + "\n";
+        context +=
+            indent +
+                color("".padStart(gutterWidth), gutterStyleSequence) +
+                gutterSeparator;
+        context += squiggleColor;
+        if (i === firstLine) {
+            const lastCharForLine = i === lastLine ? lastLineChar : void 0;
+            context += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
+            context += lineContent
+                .slice(firstLineChar, lastCharForLine)
+                .replace(/./g, "~");
+        }
+        else if (i === lastLine) {
+            context += lineContent.slice(0, lastLineChar).replace(/./g, "~");
+        }
+        else {
+            context += lineContent.replace(/./g, "~");
+        }
+        context += resetEscapeSequence;
+    }
+    return context;
+}
+function formatLocation(file, start) {
+    const { character, line } = getLineAndCharacterOfPosition(file, start);
+    const relativeFileName = displayFilename(file.fileName);
+    let output = "";
+    output += color(relativeFileName, COLOR.Cyan);
+    output += ":";
+    output += color(`${line + 1}`, COLOR.Yellow);
+    output += ":";
+    output += color(`${character + 1}`, COLOR.Yellow);
+    return output;
+}

package/lib/getNodeRange.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from "typescript";
+import { CharacterReportRange } from "@flint.fyi/core";
+export declare function getNodeRange(node: ts.Node, sourceFile: ts.SourceFile): CharacterReportRange;

package/lib/getNodeRange.js

@@ -0,0 +1,6 @@
+export function getNodeRange(node, sourceFile) {
+    return {
+        begin: node.getStart(sourceFile),
+        end: node.getEnd(),
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { typescriptLanguage } from "./language.js";
+export { ts } from "./plugin.js";

package/lib/index.js

@@ -0,0 +1,2 @@
+export { typescriptLanguage } from "./language.js";
+export { ts } from "./plugin.js";

package/lib/language.d.ts

@@ -0,0 +1,7 @@
+import * as ts from "typescript";
+import { TSNodesByName } from "./nodes.js";
+export interface TypeScriptServices {
+    sourceFile: ts.SourceFile;
+    typeChecker: ts.TypeChecker;
+}
+export declare const typescriptLanguage: import("@flint.fyi/core").Language<TSNodesByName, TypeScriptServices>;

package/lib/language.js

@@ -0,0 +1,62 @@
+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";
+const log = debugForFile(import.meta.filename);
+const projectRoot = path.join(import.meta.dirname, "../..");
+export const typescriptLanguage = createLanguage({
+    about: {
+        name: "TypeScript",
+    },
+    prepare: () => {
+        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 {
+            prepareFileOnDisk: (filePathAbsolute) => {
+                const program = servicePrograms.get(filePathAbsolute);
+                seenPrograms.add(program);
+                return createTypeScriptFileFromProjectService(filePathAbsolute, program, service);
+            },
+            prepareFileVirtually: (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 createTypeScriptFileFromProgram(program, sourceFile);
+            },
+        };
+    },
+});

package/lib/nodes.d.ts

@@ -0,0 +1,141 @@
+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;
+    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/lib/nodes.js

@@ -0,0 +1 @@
+export {};

package/lib/normalizeRange.d.ts

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

package/lib/normalizeRange.js

@@ -0,0 +1,16 @@
+export function normalizeRange(original, sourceFile) {
+    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) {
+    return typeof value === "object" && value !== null && "kind" in value;
+}
+function normalizeRangePosition(raw, sourceFile) {
+    const { character, line } = sourceFile.getLineAndCharacterOfPosition(raw);
+    return { column: character, line, raw };
+}

package/lib/plugin.d.ts

@@ -0,0 +1,15 @@
+export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, {
+    all: string[];
+}, (import("@flint.fyi/core").Rule<{
+    readonly id: "consecutiveNonNullAssertions";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "consecutiveNonNullAssertion", undefined> | import("@flint.fyi/core").Rule<{
+    readonly id: "forInArrays";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "forIn", undefined> | import("@flint.fyi/core").Rule<{
+    readonly id: "namespaceDeclarations";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferModules", {
+    readonly allowDeclarations: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    readonly allowDefinitionFiles: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}>)[]>;

package/lib/plugin.js

@@ -0,0 +1,11 @@
+import { createPlugin } from "@flint.fyi/core";
+import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
+import forInArrays from "./rules/forInArrays.js";
+import namespaceDeclarations from "./rules/namespaceDeclarations.js";
+export const ts = createPlugin({
+    globs: {
+        all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
+    },
+    name: "ts",
+    rules: [forInArrays, consecutiveNonNullAssertions, namespaceDeclarations],
+});

package/lib/rules/consecutiveNonNullAssertions.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly id: "consecutiveNonNullAssertions";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "consecutiveNonNullAssertion", undefined>;
+export default _default;

package/lib/rules/consecutiveNonNullAssertions.js

@@ -0,0 +1,39 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        id: "consecutiveNonNullAssertions",
+        preset: "logical",
+    },
+    messages: {
+        consecutiveNonNullAssertion: {
+            primary: "Consecutive non-null assertion operators are unnecessary.",
+            secondary: [
+                "The non-null assertion operator (`!`) is used to assert that a value is not null or undefined.",
+                "Using it multiple times in a row does not do anything, and just takes up space unnecessarily.",
+            ],
+            suggestions: ["Remove the redundant non-null assertion operator."],
+        },
+    },
+    setup(context) {
+        return {
+            NonNullExpression(node) {
+                if (node.parent.kind !== ts.SyntaxKind.NonNullExpression) {
+                    return;
+                }
+                const range = {
+                    begin: node.end,
+                    end: node.parent.end + 1,
+                };
+                context.report({
+                    fix: {
+                        range,
+                        text: "",
+                    },
+                    message: "consecutiveNonNullAssertion",
+                    range,
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1 @@
+export {};

package/lib/rules/consecutiveNonNullAssertions.test.js

@@ -0,0 +1,32 @@
+import rule from "./consecutiveNonNullAssertions.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+declare const outer: { inner: number } | null;
+outer!!.inner;
+`,
+            output: `
+declare const outer: { inner: number } | null;
+outer!.inner;
+`,
+            snapshot: `
+declare const outer: { inner: number } | null;
+outer!!.inner;
+     ~~
+     Consecutive non-null assertion operators are unnecessary.
+`,
+        },
+    ],
+    valid: [
+        `
+declare const outer: { inner: number } | null;
+outer!.inner;
+`,
+        `
+declare const outer: { inner: number } | null;
+outer?.inner!;
+`,
+    ],
+});

package/lib/rules/forInArrays.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly id: "forInArrays";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "forIn", undefined>;
+export default _default;