@flint.fyi/plugin-flint 0.1.0 → 0.2.1

package/lib/findProperty.d.ts

@@ -0,0 +1,3 @@
+import * as ts from "typescript";
+export declare function findProperty<Node extends ts.Node>(properties: ts.NodeArray<ts.ObjectLiteralElementLike>, name: string, predicate: (node: ts.Node) => node is Node): (ts.Expression & Node) | undefined;
+//# sourceMappingURL=findProperty.d.ts.map

package/lib/findProperty.js

@@ -0,0 +1,8 @@
+import * as ts from "typescript";
+export function findProperty(properties, name, predicate) {
+    return properties.find((property) => ts.isPropertyAssignment(property) &&
+        ts.isIdentifier(property.name) &&
+        property.name.text === name &&
+        predicate(property.initializer))?.initializer;
+}
+//# sourceMappingURL=findProperty.js.map

package/lib/flint.d.ts

@@ -1,5 +1,10 @@
 export declare const flint: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [import("@flint.fyi/core").Rule<{
+    readonly description: "Reports cases for invalid code that isn't formatted across lines.";
+    readonly id: "invalidCodeLines";
+    readonly preset: "logical";
+}, import("@flint.fyi/ts").TSNodesByName, import("@flint.fyi/ts").TypeScriptFileServices, "singleLineTest", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports test cases that are identical to previous test cases.";
     readonly id: "testCaseDuplicates";
     readonly preset: "logical";
-}, import("@flint.fyi/ts/lib/nodes.js").TSNodesByName, import("@flint.fyi/ts").TypeScriptServices, "duplicateTest", undefined>]>;
+}, import("@flint.fyi/ts").TSNodesByName, import("@flint.fyi/ts").TypeScriptFileServices, "duplicateTest", undefined>]>;
+//# sourceMappingURL=flint.d.ts.map

package/lib/flint.js

@@ -1,6 +1,8 @@
 import { createPlugin } from "@flint.fyi/core";
+import invalidCodeLines from "./rules/invalidCodeLines.js";
 import testCaseDuplicates from "./rules/testCaseDuplicates.js";
 export const flint = createPlugin({
-    name: "flint",
-    rules: [testCaseDuplicates],
+    name: "Flint",
+    rules: [invalidCodeLines, testCaseDuplicates],
 });
+//# sourceMappingURL=flint.js.map

package/lib/getRuleTesterDescribedCases.d.ts

@@ -0,0 +1,6 @@
+import * as ts from "typescript";
+export declare function getRuleTesterDescribedCases(node: ts.CallExpression): {
+    invalid: import("./types.js").ParsedTestCaseInvalid[];
+    valid: import("./types.js").ParsedTestCase[];
+} | undefined;
+//# sourceMappingURL=getRuleTesterDescribedCases.d.ts.map

package/lib/getRuleTesterDescribedCases.js

@@ -0,0 +1,32 @@
+import { isTruthy } from "@flint.fyi/utils";
+import * as ts from "typescript";
+import { findProperty } from "./findProperty.js";
+import { parseTestCase, parseTestCaseInvalid } from "./parseTestCases.js";
+export function getRuleTesterDescribedCases(node) {
+    if (!ts.isPropertyAccessExpression(node.expression) ||
+        !ts.isIdentifier(node.expression.expression) ||
+        !ts.isIdentifier(node.expression.name) ||
+        node.expression.name.text !== "describe" ||
+        node.arguments.length !== 2) {
+        return undefined;
+    }
+    // TODO: Check node.expression.expression's type for being a RuleTester
+    // https://github.com/flint-fyi/flint/issues/152
+    const argument = node.arguments[1];
+    if (!ts.isObjectLiteralExpression(argument)) {
+        return undefined;
+    }
+    const invalid = findProperty(argument.properties, "invalid", ts.isArrayLiteralExpression);
+    if (!invalid) {
+        return undefined;
+    }
+    const valid = findProperty(argument.properties, "valid", ts.isArrayLiteralExpression);
+    if (!valid) {
+        return undefined;
+    }
+    return {
+        invalid: invalid.elements.map(parseTestCaseInvalid).filter(isTruthy),
+        valid: valid.elements.map(parseTestCase).filter(isTruthy),
+    };
+}
+//# sourceMappingURL=getRuleTesterDescribedCases.js.map

package/lib/index.d.ts

@@ -1 +1,2 @@
 export * from "./flint.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1 +1,2 @@
 export * from "./flint.js";
+//# sourceMappingURL=index.js.map

package/lib/parseTestCases.d.ts

@@ -0,0 +1,5 @@
+import * as ts from "typescript";
+import type { ParsedTestCase, ParsedTestCaseInvalid } from "./types.js";
+export declare function parseTestCase(node: ts.Expression): ParsedTestCase | undefined;
+export declare function parseTestCaseInvalid(node: ts.Expression): ParsedTestCaseInvalid | undefined;
+//# sourceMappingURL=parseTestCases.d.ts.map

package/lib/parseTestCases.js

@@ -0,0 +1,63 @@
+import * as ts from "typescript";
+import { findProperty } from "./findProperty.js";
+import { tsAstToLiteral } from "./tsAstToLiteral.js";
+export function parseTestCase(node) {
+    if (ts.isStringLiteralLike(node)) {
+        return {
+            code: node.text,
+            nodes: {
+                case: node,
+                code: node,
+            },
+        };
+    }
+    if (!ts.isObjectLiteralExpression(node)) {
+        return undefined;
+    }
+    const code = findProperty(node.properties, "code", ts.isStringLiteralLike);
+    if (!code) {
+        return undefined;
+    }
+    const fileName = findProperty(node.properties, "fileName", ts.isStringLiteralLike);
+    const options = findProperty(node.properties, "options", ts.isObjectLiteralExpression);
+    return {
+        code: code.text,
+        fileName: fileName?.text,
+        nodes: {
+            case: node,
+            code,
+            fileName,
+            options,
+        },
+        options: options && tsAstToLiteral(options),
+    };
+}
+export function parseTestCaseInvalid(node) {
+    if (!ts.isObjectLiteralExpression(node)) {
+        return undefined;
+    }
+    const code = findProperty(node.properties, "code", ts.isStringLiteralLike);
+    if (!code) {
+        return undefined;
+    }
+    const fileName = findProperty(node.properties, "fileName", ts.isStringLiteralLike);
+    const options = findProperty(node.properties, "options", ts.isObjectLiteralExpression);
+    const snapshot = findProperty(node.properties, "snapshot", ts.isStringLiteralLike);
+    if (!snapshot) {
+        return undefined;
+    }
+    return {
+        code: code.text,
+        fileName: fileName?.text,
+        nodes: {
+            case: node,
+            code,
+            fileName,
+            options,
+            snapshot,
+        },
+        options: options && tsAstToLiteral(options),
+        snapshot: snapshot.text,
+    };
+}
+//# sourceMappingURL=parseTestCases.js.map

package/lib/rules/invalidCodeLines.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports cases for invalid code that isn't formatted across lines.";
+    readonly id: "invalidCodeLines";
+    readonly preset: "logical";
+}, import("@flint.fyi/ts").TSNodesByName, import("@flint.fyi/ts").TypeScriptFileServices, "singleLineTest", undefined>;
+export default _default;
+//# sourceMappingURL=invalidCodeLines.d.ts.map

package/lib/rules/invalidCodeLines.js

@@ -0,0 +1,77 @@
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
+import * as ts from "typescript";
+import { getRuleTesterDescribedCases } from "../getRuleTesterDescribedCases.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports cases for invalid code that isn't formatted across lines.",
+        id: "invalidCodeLines",
+        preset: "logical",
+    },
+    messages: {
+        singleLineTest: {
+            primary: "This code block should be formatted across multiple lines for more readable reports.",
+            secondary: [
+                "When writing `invalid` case code blocks, it's better to start code on a new line in a template literal string.",
+                "Doing so allows the case's `snapshot` to visualize the `~` characters visually underneath reported ranges.",
+            ],
+            suggestions: [
+                "Delete this redundant test case.",
+                "Change a property to make the test case unique.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkTestCase(testCase, sourceFile) {
+            if (!testCase.code.startsWith("\n")) {
+                context.report({
+                    fix: [
+                        createFixForCode(testCase, sourceFile),
+                        createFixForSnapshot(testCase, sourceFile),
+                    ],
+                    message: "singleLineTest",
+                    range: getTSNodeRange(testCase.nodes.code, sourceFile),
+                });
+            }
+        }
+        function createFixForCode(testCase, sourceFile) {
+            if (ts.isStringLiteral(testCase.nodes.code)) {
+                return {
+                    range: getTSNodeRange(testCase.nodes.code, sourceFile),
+                    text: `\`\n${testCase.code}\n\``,
+                };
+            }
+            const begin = testCase.nodes.code.getStart(sourceFile) + 1;
+            return {
+                range: {
+                    begin,
+                    end: begin,
+                },
+                text: "\n",
+            };
+        }
+        function createFixForSnapshot(testCase, sourceFile) {
+            const begin = testCase.nodes.snapshot.getStart(sourceFile) + 1;
+            return {
+                range: {
+                    begin,
+                    end: begin,
+                },
+                text: "\n",
+            };
+        }
+        return {
+            visitors: {
+                CallExpression(node, { sourceFile }) {
+                    const describedCases = getRuleTesterDescribedCases(node);
+                    if (!describedCases) {
+                        return;
+                    }
+                    describedCases.invalid.forEach((testCase) => {
+                        checkTestCase(testCase, sourceFile);
+                    });
+                },
+            },
+        };
+    },
+});
+//# sourceMappingURL=invalidCodeLines.js.map

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

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

package/lib/rules/invalidCodeLines.test.js

@@ -0,0 +1,198 @@
+import rule from "./invalidCodeLines.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: "",
+        snapshot: \`
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+            output: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`
+
+\`,
+        snapshot: \`
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+            snapshot: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: "",
+              ~~
+              This code block should be formatted across multiple lines for more readable reports.
+        snapshot: \`
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+        },
+        {
+            code: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log(
+);\`,
+        snapshot: \`console.log(
+);
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+            output: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`
+console.log(
+);
+\`,
+        snapshot: \`
+console.log(
+);
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+            snapshot: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log(
+              ~~~~~~~~~~~~~
+              This code block should be formatted across multiple lines for more readable reports.
+);\`,
+~~~
+        snapshot: \`console.log(
+);
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+        },
+        {
+            code: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log();\`,
+        snapshot: \`console.log();
+~~~~~~~~~~~~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+            output: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`
+console.log();
+\`,
+        snapshot: \`
+console.log();
+~~~~~~~~~~~~~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+            snapshot: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log();\`,
+              ~~~~~~~~~~~~~~~~
+              This code block should be formatted across multiple lines for more readable reports.
+        snapshot: \`console.log();
+~~~~~~~~~~~~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+        },
+    ],
+    valid: [
+        `
+            ruleTester.describe(rule, {
+                valid: [],
+                invalid: []
+            });
+    `,
+        `
+            ruleTester.describe(rule, {
+                valid: [],
+                invalid: [
+                {
+                    code: \`
+\`,
+                    snapshot: \`
+~
+\`,
+    }
+                ],
+            });
+    `,
+        `
+            ruleTester.describe(rule, {
+                valid: [],
+                invalid: [
+                {
+                    code: \`
+console.log();
+\`,
+                    snapshot: \`
+~~~~~~~~~~~~
+Rule report message.
+\`,
+    }
+                ],
+            });
+    `,
+    ],
+});
+//# sourceMappingURL=invalidCodeLines.test.js.map

package/lib/rules/ruleTester.d.ts

@@ -1,2 +1,3 @@
 import { RuleTester } from "@flint.fyi/rule-tester";
 export declare const ruleTester: RuleTester;
+//# sourceMappingURL=ruleTester.d.ts.map

package/lib/rules/ruleTester.js

@@ -1,3 +1,8 @@
 import { RuleTester } from "@flint.fyi/rule-tester";
 import { describe, it } from "vitest";
-export const ruleTester = new RuleTester({ describe, it });
+export const ruleTester = new RuleTester({
+    defaults: { fileName: "file.test.ts" },
+    describe,
+    it,
+});
+//# sourceMappingURL=ruleTester.js.map

package/lib/rules/testCaseDuplicates.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports test cases that are identical to previous test cases.";
     readonly id: "testCaseDuplicates";
     readonly preset: "logical";
-}, import("@flint.fyi/ts/lib/nodes.js").TSNodesByName, import("@flint.fyi/ts").TypeScriptServices, "duplicateTest", undefined>;
+}, import("@flint.fyi/ts").TSNodesByName, import("@flint.fyi/ts").TypeScriptFileServices, "duplicateTest", undefined>;
 export default _default;
+//# sourceMappingURL=testCaseDuplicates.d.ts.map

package/lib/rules/testCaseDuplicates.js

@@ -1,5 +1,5 @@
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
-import { getRuleTesterDescribedCases, } from "./getRuleTesterDescribedCases.js";
+import { getRuleTesterDescribedCases } from "../getRuleTesterDescribedCases.js";
 export default typescriptLanguage.createRule({
     about: {
         description: "Reports test cases that are identical to previous test cases.",
@@ -20,7 +20,7 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkTestCases(testCases) {
+        function checkTestCases(testCases, sourceFile) {
             const seen = new Set();
             for (const testCase of testCases) {
                 const key = JSON.stringify({
@@ -31,7 +31,7 @@ export default typescriptLanguage.createRule({
                 if (seen.has(key)) {
                     context.report({
                         message: "duplicateTest",
-                        range: getTSNodeRange(testCase.node, context.sourceFile),
+                        range: getTSNodeRange(testCase.nodes.case, sourceFile),
                     });
                 }
                 else {
@@ -41,15 +41,16 @@ export default typescriptLanguage.createRule({
         }
         return {
             visitors: {
-                CallExpression(node) {
+                CallExpression(node, { sourceFile }) {
                     const describedCases = getRuleTesterDescribedCases(node);
                     if (!describedCases) {
                         return;
                     }
-                    checkTestCases(describedCases.invalid);
-                    checkTestCases(describedCases.valid);
+                    checkTestCases(describedCases.invalid, sourceFile);
+                    checkTestCases(describedCases.valid, sourceFile);
                 },
             },
         };
     },
 });
+//# sourceMappingURL=testCaseDuplicates.js.map

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

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

package/lib/rules/testCaseDuplicates.test.js

@@ -171,3 +171,4 @@ ruleTester.describe(rule, {
         `,
     ],
 });
+//# sourceMappingURL=testCaseDuplicates.test.js.map

package/lib/{rules/tsAstToLiteral.d.ts → tsAstToLiteral.d.ts}

@@ -2,3 +2,4 @@ import ts from "typescript";
 export declare function tsAstToLiteral(node: ts.ArrayLiteralExpression): unknown[];
 export declare function tsAstToLiteral(node: ts.ObjectLiteralExpression): object;
 export declare function tsAstToLiteral(node: ts.Node): unknown;
+//# sourceMappingURL=tsAstToLiteral.d.ts.map

package/lib/{rules/tsAstToLiteral.js → tsAstToLiteral.js}

@@ -35,3 +35,4 @@ export function tsAstToLiteral(node) {
     }
     return undefined;
 }
+//# sourceMappingURL=tsAstToLiteral.js.map

package/lib/types.d.ts

@@ -0,0 +1,18 @@
+import type { InvalidTestCase, TestCase } from "@flint.fyi/rule-tester";
+import * as ts from "typescript";
+export interface ParsedTestCase extends TestCase {
+    nodes: ParsedTestCaseNodes;
+}
+export interface ParsedTestCaseInvalid extends InvalidTestCase {
+    nodes: ParsedTestCaseNodesInvalid;
+}
+export interface ParsedTestCaseNodes {
+    case: ts.Node;
+    code: ts.StringLiteralLike;
+    fileName?: ts.StringLiteralLike;
+    options?: ts.ObjectLiteralExpression;
+}
+export interface ParsedTestCaseNodesInvalid extends ParsedTestCaseNodes {
+    snapshot: ts.Node;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.js

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

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@flint.fyi/plugin-flint",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "[Experimental] A Flint plugin for linting Flint plugins.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JoshuaKGoldberg/flint",
+    "url": "git+https://github.com/flint-fyi/flint.git",
     "directory": "packages/plugin-flint"
   },
   "license": "MIT",
@@ -12,19 +12,29 @@
     "name": "JoshuaKGoldberg",
     "email": "npm@joshuakgoldberg.com"
   },
+  "sideEffects": false,
   "type": "module",
-  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map"
+  ],
   "dependencies": {
     "@flint.fyi/core": "",
-    "@flint.fyi/rule-tester": "",
     "@flint.fyi/ts": "",
-    "@flint.fyi/utils": ""
+    "@flint.fyi/utils": "",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@flint.fyi/rule-tester": "",
+    "vitest": "4.0.15"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
   }
 }

package/CHANGELOG.md

@@ -1,30 +0,0 @@
-# @flint.fyi/plugin-flint
-
-## 0.1.0
-
-### Minor Changes
-
-- d89c480: feat(comparisons): add eslint-plugin-eslint-plugin comparisons
-
-### Patch Changes
-
-- Updated dependencies [738fe36]
-  - @flint.fyi/rule-tester@0.14.3
-
-## 0.0.2
-
-### Patch Changes
-
-- 0b80834: allow rules to indicate dependencies
-- 63b61e5: add --suggestions to CLI
-- Updated dependencies [0b80834]
-- Updated dependencies [63b61e5]
-  - @flint.fyi/core@0.13.5
-  - @flint.fyi/ts@0.13.2
-  - @flint.fyi/utils@0.13.2
-
-## 0.0.1
-
-### Patch Changes
-
-- 83a4361: initial functionality

package/lib/rules/getRuleTesterDescribedCases.d.ts

@@ -1,9 +0,0 @@
-import { TestCase } from "@flint.fyi/rule-tester";
-import * as ts from "typescript";
-export interface ParsedTestCase extends TestCase {
-    node: ts.Node;
-}
-export declare function getRuleTesterDescribedCases(node: ts.CallExpression): {
-    invalid: ParsedTestCase[];
-    valid: ParsedTestCase[];
-} | undefined;