@codeperfect/eslint-plugin 1.0.0

package/dist/testing/assert-actual-expected-names/index.js

@@ -0,0 +1,2 @@
+export { assertActualExpectedNamesRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdGluZy9hc3NlcnQtYWN0dWFsLWV4cGVjdGVkLW5hbWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xuIl19

package/dist/testing/assert-actual-expected-names/rule.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const assertActualExpectedNamesRule: Rule.RuleModule;
+export { assertActualExpectedNamesRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/testing/assert-actual-expected-names/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/testing/assert-actual-expected-names/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAWnC,QAAA,MAAM,6BAA6B,EAAE,IAAI,CAAC,UA8DzC,CAAC;AAEF,OAAO,EAAE,6BAA6B,EAAE,CAAC"}

package/dist/testing/assert-actual-expected-names/rule.js

@@ -0,0 +1,54 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { analyzeTestBlock, getAssertDeclaredIdentifiers, getAssertionIdentifiers, hasAssertion, usesPrefix, } from "../aaa";
+const assertActualExpectedNamesRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                const declaredIdentifiers = getAssertDeclaredIdentifiers(analysis);
+                const reportedNames = new Set();
+                for (const statement of analysis.statements) {
+                    if (statement.phase !== "Assert" || !hasAssertion(statement.node)) {
+                        continue;
+                    }
+                    const { actual, expected } = getAssertionIdentifiers(statement.node);
+                    if (actual !== void 0 &&
+                        declaredIdentifiers.has(actual) &&
+                        !usesPrefix(actual, "actual") &&
+                        !reportedNames.has(`actual:${actual}`)) {
+                        reportedNames.add(`actual:${actual}`);
+                        context.report({
+                            data: { name: actual, prefix: "actual" },
+                            messageId: "missingPrefix",
+                            node: declaredIdentifiers.get(actual),
+                        });
+                    }
+                    if (expected !== void 0 &&
+                        declaredIdentifiers.has(expected) &&
+                        !usesPrefix(expected, "expected") &&
+                        !reportedNames.has(`expected:${expected}`)) {
+                        reportedNames.add(`expected:${expected}`);
+                        context.report({
+                            data: { name: expected, prefix: "expected" },
+                            messageId: "missingPrefix",
+                            node: declaredIdentifiers.get(expected),
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("assert-actual-expected-names", "Require Assert-phase comparison variables to use actual*/expected* prefixes."),
+        messages: {
+            missingPrefix: "Rename '{{name}}' to use the '{{prefix}}' prefix when comparing values inside // Assert.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { assertActualExpectedNamesRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/testing/enforce-aaa-phase-purity/index.d.ts

@@ -0,0 +1,2 @@
+export { enforceAaaPhasePurityRule } from "./rule";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/enforce-aaa-phase-purity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/enforce-aaa-phase-purity/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/enforce-aaa-phase-purity/index.js

@@ -0,0 +1,2 @@
+export { enforceAaaPhasePurityRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdGluZy9lbmZvcmNlLWFhYS1waGFzZS1wdXJpdHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZW5mb3JjZUFhYVBoYXNlUHVyaXR5UnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcbiJdfQ==

package/dist/testing/enforce-aaa-phase-purity/rule.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const enforceAaaPhasePurityRule: Rule.RuleModule;
+export { enforceAaaPhasePurityRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/testing/enforce-aaa-phase-purity/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/testing/enforce-aaa-phase-purity/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAcnC,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UA6HrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/testing/enforce-aaa-phase-purity/rule.js

@@ -0,0 +1,110 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { analyzeTestBlock, hasAssertion, hasAsyncLogic, hasAwait, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, } from "../aaa";
+const enforceAaaPhasePurityRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                const hasAllSections = ["Arrange", "Act", "Assert"].every((phase) => analysis.sectionComments.some((sectionComment) => sectionComment.phases.includes(phase)));
+                if (!hasAllSections) {
+                    return;
+                }
+                let hasMeaningfulAct = false;
+                for (const statement of analysis.statements) {
+                    if (statement.phase === "Arrange") {
+                        if (hasAssertion(statement.node)) {
+                            context.report({
+                                messageId: "assertionOutsideAssert",
+                                node: statement.node,
+                            });
+                        }
+                        if (hasAwait(statement.node)) {
+                            context.report({
+                                messageId: "awaitOutsideAct",
+                                node: statement.node,
+                            });
+                        }
+                        if (hasAsyncLogic(statement.node)) {
+                            context.report({
+                                messageId: "asyncInArrange",
+                                node: statement.node,
+                            });
+                        }
+                        if (isMeaningfulActStatement(statement.node)) {
+                            context.report({
+                                messageId: "actionInArrange",
+                                node: statement.node,
+                            });
+                        }
+                        continue;
+                    }
+                    if (statement.phase === "Act") {
+                        hasMeaningfulAct ||= isMeaningfulActStatement(statement.node);
+                        if (hasAssertion(statement.node)) {
+                            context.report({
+                                messageId: "assertionOutsideAssert",
+                                node: statement.node,
+                            });
+                        }
+                        if (isSetupLikeStatement(statement.node)) {
+                            context.report({
+                                messageId: "setupAfterAct",
+                                node: statement.node,
+                            });
+                        }
+                        continue;
+                    }
+                    /* v8 ignore start -- concrete Assert-phase behaviors are covered by rule tests; this guard's remaining branch artifact comes from source-mapped phase discrimination. */
+                    if (statement.phase === "Assert") {
+                        if (hasAwait(statement.node)) {
+                            context.report({
+                                messageId: "awaitOutsideAct",
+                                node: statement.node,
+                            });
+                        }
+                        if (hasMutation(statement.node)) {
+                            context.report({
+                                messageId: "mutationAfterAct",
+                                node: statement.node,
+                            });
+                            continue;
+                        }
+                        if (!isValidAssertStatement(statement.node)) {
+                            context.report({
+                                messageId: "nonAssertionInAssert",
+                                node: statement.node,
+                            });
+                        }
+                    }
+                    /* v8 ignore stop */
+                }
+                if (!hasMeaningfulAct) {
+                    context.report({
+                        messageId: "missingMeaningfulAct",
+                        node: analysis.callExpression,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("enforce-aaa-phase-purity", "Keep setup, action, and assertions inside their intended AAA phases."),
+        messages: {
+            actionInArrange: "Keep the function under test out of Arrange; reserve Arrange for setup only.",
+            assertionOutsideAssert: "Move assertions into the // Assert section so test logic does not leak earlier.",
+            asyncInArrange: "Do not trigger async behavior in Arrange.",
+            awaitOutsideAct: "Use await only inside the // Act section.",
+            missingMeaningfulAct: "The // Act section must contain a meaningful SUT interaction, not only utility or setup calls.",
+            mutationAfterAct: "Do not mutate test data after the // Act section has run.",
+            nonAssertionInAssert: "Keep the // Assert section focused on assertions and assertion-local values.",
+            setupAfterAct: "Do not continue arranging test data after the // Act section has started.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { enforceAaaPhasePurityRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/testing/enforce-aaa-phase-purity/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\nimport {\n  analyzeTestBlock,\n  hasAssertion,\n  hasAsyncLogic,\n  hasAwait,\n  hasMutation,\n  isMeaningfulActStatement,\n  isSetupLikeStatement,\n  isValidAssertStatement,\n} from \"../aaa\";\n\nconst enforceAaaPhasePurityRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return {\n      CallExpression(node): void {\n        const analysis = analyzeTestBlock(context, node);\n        if (analysis === void 0) {\n          return;\n        }\n\n        const hasAllSections = [\"Arrange\", \"Act\", \"Assert\"].every((phase) =>\n          analysis.sectionComments.some((sectionComment) =>\n            sectionComment.phases.includes(phase as never),\n          ),\n        );\n        if (!hasAllSections) {\n          return;\n        }\n\n        let hasMeaningfulAct = false;\n\n        for (const statement of analysis.statements) {\n          if (statement.phase === \"Arrange\") {\n            if (hasAssertion(statement.node)) {\n              context.report({\n                messageId: \"assertionOutsideAssert\",\n                node: statement.node,\n              });\n            }\n            if (hasAwait(statement.node)) {\n              context.report({\n                messageId: \"awaitOutsideAct\",\n                node: statement.node,\n              });\n            }\n            if (hasAsyncLogic(statement.node)) {\n              context.report({\n                messageId: \"asyncInArrange\",\n                node: statement.node,\n              });\n            }\n            if (isMeaningfulActStatement(statement.node)) {\n              context.report({\n                messageId: \"actionInArrange\",\n                node: statement.node,\n              });\n            }\n            continue;\n          }\n\n          if (statement.phase === \"Act\") {\n            hasMeaningfulAct ||= isMeaningfulActStatement(statement.node);\n\n            if (hasAssertion(statement.node)) {\n              context.report({\n                messageId: \"assertionOutsideAssert\",\n                node: statement.node,\n              });\n            }\n            if (isSetupLikeStatement(statement.node)) {\n              context.report({\n                messageId: \"setupAfterAct\",\n                node: statement.node,\n              });\n            }\n            continue;\n          }\n\n          /* v8 ignore start -- concrete Assert-phase behaviors are covered by rule tests; this guard's remaining branch artifact comes from source-mapped phase discrimination. */\n          if (statement.phase === \"Assert\") {\n            if (hasAwait(statement.node)) {\n              context.report({\n                messageId: \"awaitOutsideAct\",\n                node: statement.node,\n              });\n            }\n            if (hasMutation(statement.node)) {\n              context.report({\n                messageId: \"mutationAfterAct\",\n                node: statement.node,\n              });\n              continue;\n            }\n            if (!isValidAssertStatement(statement.node)) {\n              context.report({\n                messageId: \"nonAssertionInAssert\",\n                node: statement.node,\n              });\n            }\n          }\n          /* v8 ignore stop */\n        }\n\n        if (!hasMeaningfulAct) {\n          context.report({\n            messageId: \"missingMeaningfulAct\",\n            node: analysis.callExpression,\n          });\n        }\n      },\n    } satisfies Rule.RuleListener;\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"enforce-aaa-phase-purity\",\n      \"Keep setup, action, and assertions inside their intended AAA phases.\",\n    ),\n    messages: {\n      actionInArrange:\n        \"Keep the function under test out of Arrange; reserve Arrange for setup only.\",\n      assertionOutsideAssert:\n        \"Move assertions into the // Assert section so test logic does not leak earlier.\",\n      asyncInArrange: \"Do not trigger async behavior in Arrange.\",\n      awaitOutsideAct: \"Use await only inside the // Act section.\",\n      missingMeaningfulAct:\n        \"The // Act section must contain a meaningful SUT interaction, not only utility or setup calls.\",\n      mutationAfterAct:\n        \"Do not mutate test data after the // Act section has run.\",\n      nonAssertionInAssert:\n        \"Keep the // Assert section focused on assertions and assertion-local values.\",\n      setupAfterAct:\n        \"Do not continue arranging test data after the // Act section has started.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\nexport { enforceAaaPhasePurityRule };\n"]}

package/dist/testing/enforce-aaa-structure/index.d.ts

@@ -0,0 +1,2 @@
+export { enforceAaaStructureRule } from "./rule";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/enforce-aaa-structure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/enforce-aaa-structure/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/enforce-aaa-structure/index.js

@@ -0,0 +1,2 @@
+export { enforceAaaStructureRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdGluZy9lbmZvcmNlLWFhYS1zdHJ1Y3R1cmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUgfSBmcm9tIFwiLi9ydWxlXCI7XG4iXX0=

package/dist/testing/enforce-aaa-structure/rule.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const enforceAaaStructureRule: Rule.RuleModule;
+export { enforceAaaStructureRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/testing/enforce-aaa-structure/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/testing/enforce-aaa-structure/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAoDnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/testing/enforce-aaa-structure/rule.js

@@ -0,0 +1,48 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { aaaPhaseOrder, analyzeTestBlock, getFlattenedSections } from "../aaa";
+const enforceAaaStructureRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                const flattenedSections = getFlattenedSections(analysis);
+                const seenPhases = new Set();
+                let lastPhaseOrder = -1;
+                for (const section of flattenedSections) {
+                    if (seenPhases.has(section.phase)) {
+                        context.report({
+                            data: { section: section.phase },
+                            messageId: "duplicateSection",
+                            node: section.comment,
+                        });
+                        continue;
+                    }
+                    const currentPhaseOrder = aaaPhaseOrder[section.phase];
+                    if (currentPhaseOrder < lastPhaseOrder) {
+                        context.report({
+                            data: { section: section.phase },
+                            messageId: "invalidOrder",
+                            node: section.comment,
+                        });
+                    }
+                    lastPhaseOrder = Math.max(lastPhaseOrder, currentPhaseOrder);
+                    seenPhases.add(section.phase);
+                }
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("enforce-aaa-structure", "Require AAA sections to appear once and in Arrange, Act, Assert order."),
+        messages: {
+            duplicateSection: "Use the // {{section}} section comment only once per test.",
+            invalidOrder: "Move the // {{section}} section comment so AAA phases stay in Arrange, Act, Assert order.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { enforceAaaStructureRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/testing/index.d.ts

@@ -0,0 +1,9 @@
+export { assertActualExpectedNamesRule } from "./assert-actual-expected-names";
+export { enforceAaaPhasePurityRule } from "./enforce-aaa-phase-purity";
+export { enforceAaaStructureRule } from "./enforce-aaa-structure";
+export { preferViMockedImportRule } from "./prefer-vi-mocked-import";
+export { requireAaaSectionsRule } from "./require-aaa-sections";
+export { requireActResultCaptureRule } from "./require-act-result-capture";
+export { requireTestCompanionRule } from "./require-test-companion";
+export { singleActStatementRule } from "./single-act-statement";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,9 @@
+export { assertActualExpectedNamesRule } from "./assert-actual-expected-names";
+export { enforceAaaPhasePurityRule } from "./enforce-aaa-phase-purity";
+export { enforceAaaStructureRule } from "./enforce-aaa-structure";
+export { preferViMockedImportRule } from "./prefer-vi-mocked-import";
+export { requireAaaSectionsRule } from "./require-aaa-sections";
+export { requireActResultCaptureRule } from "./require-act-result-capture";
+export { requireTestCompanionRule } from "./require-test-companion";
+export { singleActStatementRule } from "./single-act-statement";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUMvRSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN2RSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNsRSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNyRSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNoRSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNwRSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlIH0gZnJvbSBcIi4vYXNzZXJ0LWFjdHVhbC1leHBlY3RlZC1uYW1lc1wiO1xuZXhwb3J0IHsgZW5mb3JjZUFhYVBoYXNlUHVyaXR5UnVsZSB9IGZyb20gXCIuL2VuZm9yY2UtYWFhLXBoYXNlLXB1cml0eVwiO1xuZXhwb3J0IHsgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUgfSBmcm9tIFwiLi9lbmZvcmNlLWFhYS1zdHJ1Y3R1cmVcIjtcbmV4cG9ydCB7IHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSB9IGZyb20gXCIuL3ByZWZlci12aS1tb2NrZWQtaW1wb3J0XCI7XG5leHBvcnQgeyByZXF1aXJlQWFhU2VjdGlvbnNSdWxlIH0gZnJvbSBcIi4vcmVxdWlyZS1hYWEtc2VjdGlvbnNcIjtcbmV4cG9ydCB7IHJlcXVpcmVBY3RSZXN1bHRDYXB0dXJlUnVsZSB9IGZyb20gXCIuL3JlcXVpcmUtYWN0LXJlc3VsdC1jYXB0dXJlXCI7XG5leHBvcnQgeyByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUgfSBmcm9tIFwiLi9yZXF1aXJlLXRlc3QtY29tcGFuaW9uXCI7XG5leHBvcnQgeyBzaW5nbGVBY3RTdGF0ZW1lbnRSdWxlIH0gZnJvbSBcIi4vc2luZ2xlLWFjdC1zdGF0ZW1lbnRcIjtcbiJdfQ==

package/dist/testing/prefer-vi-mocked-import/fix.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+import type { RuleMatch } from "./types";
+/**
+ * Builds all autofix operations for a single match.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Combined fix list.
+ * @example
+ * ```typescript
+ * const fixes = buildFix({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+declare function buildFix(match: RuleMatch, fixer: Rule.RuleFixer): Rule.Fix[];
+export { buildFix };
+//# sourceMappingURL=fix.d.ts.map

package/dist/testing/prefer-vi-mocked-import/fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix.d.ts","sourceRoot":"","sources":["../../../src/testing/prefer-vi-mocked-import/fix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAqCzC;;;;;;;;;;GAUG;AACH,iBAAS,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAQrE;AAiPD,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/testing/prefer-vi-mocked-import/fix.js

@@ -0,0 +1,224 @@
+/**
+ * Builds fixes that inline declaration initializers into factory properties.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Binding-related fixes.
+ * @example
+ * ```typescript
+ * const fixes = buildBindingFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildBindingFixes(match, fixer) {
+    return match.bindings.flatMap((binding) => {
+        const declaration = match.declarations.get(binding.localName);
+        if (declaration === void 0) {
+            return [];
+        }
+        const initializerText = match.sourceText.slice(declaration.initializerRange[0], declaration.initializerRange[1]);
+        return [
+            fixer.replaceTextRange(binding.propertyRange, `${binding.exportedName}: ${initializerText}`),
+        ];
+    });
+}
+/**
+ * Builds all autofix operations for a single match.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Combined fix list.
+ * @example
+ * ```typescript
+ * const fixes = buildFix({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildFix(match, fixer) {
+    return [
+        ...buildBindingFixes(match, fixer),
+        ...buildMemberRewriteFixes(match, fixer),
+        ...buildMockSpecifierFixes(match, fixer),
+        ...buildImportFixes(match, fixer),
+        ...buildRemovalFixes(match, fixer),
+    ];
+}
+/**
+ * Builds fixes for adding or updating imports.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns A fix list that keeps import declarations consistent.
+ * @example
+ * ```typescript
+ * const fixes = buildImportFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildImportFixes(match, fixer) {
+    const { names } = match.importPlan;
+    if (names.length === 0) {
+        return [];
+    }
+    const sortedNames = [...names].toSorted();
+    const updateFix = buildImportUpdateFix(match, sortedNames, fixer);
+    return updateFix === void 0
+        ? buildImportInsertFixes(match, sortedNames, fixer)
+        : [updateFix];
+}
+/**
+ * Builds import insertion fixes when no compatible import exists.
+ * @param match Autofix context produced by the matcher.
+ * @param sortedNames Sorted names that must be imported.
+ * @param fixer ESLint fixer.
+ * @returns Fixes that insert a new import declaration.
+ * @example
+ * ```typescript
+ * const fixes = buildImportInsertFixes({ importPlan: { moduleSpecifier: "./x", names: [] }, newline: "\n" } as never, [], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildImportInsertFixes(match, sortedNames, fixer) {
+    const statementText = buildImportStatement(match.importPlan.moduleSpecifier, void 0, sortedNames);
+    const { afterRange } = match.importPlan.insert ?? {};
+    return afterRange === void 0
+        ? [
+            fixer.insertTextBeforeRange([0, 0], `${statementText}${match.newline}${match.newline}`),
+        ]
+        : [
+            fixer.insertTextAfterRange(afterRange, `${match.newline}${statementText}`),
+        ];
+}
+/**
+ * Creates an import statement string from import parts.
+ * @param moduleSpecifier Module path used in the generated statement.
+ * @param defaultImportName Existing default-import local identifier, when present.
+ * @param names Named imports to include in braces.
+ * @returns Fully formatted import statement text.
+ * @example
+ * ```typescript
+ * const text = buildImportStatement("./x", void 0, ["a"]);
+ * void text;
+ * ```
+ */
+function buildImportStatement(moduleSpecifier, defaultImportName, names) {
+    const moduleText = JSON.stringify(moduleSpecifier);
+    const namedText = `{ ${names.join(", ")} }`;
+    return defaultImportName === void 0
+        ? `import ${namedText} from ${moduleText};`
+        : `import ${defaultImportName}, ${namedText} from ${moduleText};`;
+}
+/**
+ * Builds an import update fix when an existing import is compatible.
+ * @param match Autofix context produced by the matcher.
+ * @param sortedNames Sorted names that must be imported.
+ * @param fixer ESLint fixer.
+ * @returns A single replacement fix when an import can be updated.
+ * @example
+ * ```typescript
+ * const fix = buildImportUpdateFix({ importPlan: { moduleSpecifier: "./x", names: [] } } as never, [], {} as never);
+ * void fix;
+ * ```
+ */
+function buildImportUpdateFix(match, sortedNames, fixer) {
+    const { update } = match.importPlan;
+    if (update === void 0) {
+        return void 0;
+    }
+    const { moduleSpecifier } = match.importPlan;
+    const mergedNames = [
+        ...new Set([...sortedNames, ...update.existingNamedImports]),
+    ].toSorted();
+    const statementText = buildImportStatement(moduleSpecifier, update.defaultImportName, mergedNames);
+    return fixer.replaceTextRange(update.range, statementText);
+}
+/**
+ * Builds fixes for `mock*` member-expression object rewrites.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Replacements for member-expression object identifiers.
+ * @example
+ * ```typescript
+ * const fixes = buildMemberRewriteFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildMemberRewriteFixes(match, fixer) {
+    return match.memberRewrites.map((rewrite) => fixer.replaceTextRange(rewrite.localObjectRange, `vi.mocked(${rewrite.exportedName})`));
+}
+/**
+ * Builds a fix that converts literal mock specifiers to `import("...")`.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Fixes that normalize the mock specifier argument.
+ * @example
+ * ```typescript
+ * const fixes = buildMockSpecifierFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildMockSpecifierFixes(match, fixer) {
+    if (match.mockSpecifierIsImportExpression) {
+        return [];
+    }
+    const moduleText = JSON.stringify(match.moduleSpecifier);
+    return [
+        fixer.replaceTextRange(match.mockSpecifierRange, `import(${moduleText})`),
+    ];
+}
+/**
+ * Builds fixes that remove declarations after inlining.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Fixes that remove redundant declaration statements.
+ * @example
+ * ```typescript
+ * const fixes = buildRemovalFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildRemovalFixes(match, fixer) {
+    const uniqueRanges = getUniqueStatementRanges(match);
+    return uniqueRanges.map((statementRange) => {
+        const expandedRange = extendRangeToLineBreak(match.sourceText, statementRange);
+        return fixer.removeRange(expandedRange);
+    });
+}
+/**
+ * Extends a statement range to include the trailing line break.
+ * @param sourceText Full file content for newline lookup.
+ * @param statementRange Start/end offsets for the statement.
+ * @returns Statement range extended through the trailing line break.
+ * @example
+ * ```typescript
+ * const range = extendRangeToLineBreak("a\n", [0, 1]);
+ * void range;
+ * ```
+ */
+function extendRangeToLineBreak(sourceText, statementRange) {
+    const [start, end] = statementRange;
+    const nextLineFeedIndex = sourceText.indexOf("\n", end);
+    return nextLineFeedIndex === -1
+        ? [start, sourceText.length]
+        : [start, nextLineFeedIndex + 1];
+}
+/**
+ * Returns sorted unique statement ranges for declarations to remove.
+ * @param match Autofix context produced by the matcher.
+ * @returns Distinct declaration statement ranges to remove.
+ * @example
+ * ```typescript
+ * const ranges = getUniqueStatementRanges({ bindings: [], declarations: new Map() } as never);
+ * void ranges;
+ * ```
+ */
+function getUniqueStatementRanges(match) {
+    const rangeMap = new Map();
+    for (const binding of match.bindings) {
+        const declaration = match.declarations.get(binding.localName);
+        if (declaration !== void 0) {
+            const key = `${declaration.statementRange[0]}:${declaration.statementRange[1]}`;
+            rangeMap.set(key, declaration.statementRange);
+        }
+    }
+    return [...rangeMap.values()];
+}
+export { buildFix };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fix.js","sourceRoot":"","sources":["../../../src/testing/prefer-vi-mocked-import/fix.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { RuleMatch } from \"./types\";\n/** Type definition for rule data. */\ntype Range = [number, number];\n\n/**\n * Builds fixes that inline declaration initializers into factory properties.\n * @param match Autofix context produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns Binding-related fixes.\n * @example\n * ```typescript\n * const fixes = buildBindingFixes({} as never, {} as never);\n * void fixes;\n * ```\n */\nfunction buildBindingFixes(\n  match: RuleMatch,\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  return match.bindings.flatMap((binding) => {\n    const declaration = match.declarations.get(binding.localName);\n    if (declaration === void 0) {\n      return [];\n    }\n    const initializerText = match.sourceText.slice(\n      declaration.initializerRange[0],\n      declaration.initializerRange[1],\n    );\n    return [\n      fixer.replaceTextRange(\n        binding.propertyRange,\n        `${binding.exportedName}: ${initializerText}`,\n      ),\n    ];\n  });\n}\n\n/**\n * Builds all autofix operations for a single match.\n * @param match Autofix context produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns Combined fix list.\n * @example\n * ```typescript\n * const fixes = buildFix({} as never, {} as never);\n * void fixes;\n * ```\n */\nfunction buildFix(match: RuleMatch, fixer: Rule.RuleFixer): Rule.Fix[] {\n  return [\n    ...buildBindingFixes(match, fixer),\n    ...buildMemberRewriteFixes(match, fixer),\n    ...buildMockSpecifierFixes(match, fixer),\n    ...buildImportFixes(match, fixer),\n    ...buildRemovalFixes(match, fixer),\n  ];\n}\n\n/**\n * Builds fixes for adding or updating imports.\n * @param match Autofix context produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns A fix list that keeps import declarations consistent.\n * @example\n * ```typescript\n * const fixes = buildImportFixes({} as never, {} as never);\n * void fixes;\n * ```\n */\nfunction buildImportFixes(match: RuleMatch, fixer: Rule.RuleFixer): Rule.Fix[] {\n  const { names } = match.importPlan;\n  if (names.length === 0) {\n    return [];\n  }\n\n  const sortedNames = [...names].toSorted();\n  const updateFix = buildImportUpdateFix(match, sortedNames, fixer);\n  return updateFix === void 0\n    ? buildImportInsertFixes(match, sortedNames, fixer)\n    : [updateFix];\n}\n\n/**\n * Builds import insertion fixes when no compatible import exists.\n * @param match Autofix context produced by the matcher.\n * @param sortedNames Sorted names that must be imported.\n * @param fixer ESLint fixer.\n * @returns Fixes that insert a new import declaration.\n * @example\n * ```typescript\n * const fixes = buildImportInsertFixes({ importPlan: { moduleSpecifier: \"./x\", names: [] }, newline: \"\\n\" } as never, [], {} as never);\n * void fixes;\n * ```\n */\nfunction buildImportInsertFixes(\n  match: RuleMatch,\n  sortedNames: string[],\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  const statementText = buildImportStatement(\n    match.importPlan.moduleSpecifier,\n    void 0,\n    sortedNames,\n  );\n  const { afterRange } = match.importPlan.insert ?? {};\n\n  return afterRange === void 0\n    ? [\n        fixer.insertTextBeforeRange(\n          [0, 0],\n          `${statementText}${match.newline}${match.newline}`,\n        ),\n      ]\n    : [\n        fixer.insertTextAfterRange(\n          afterRange,\n          `${match.newline}${statementText}`,\n        ),\n      ];\n}\n\n/**\n * Creates an import statement string from import parts.\n * @param moduleSpecifier Module path used in the generated statement.\n * @param defaultImportName Existing default-import local identifier, when present.\n * @param names Named imports to include in braces.\n * @returns Fully formatted import statement text.\n * @example\n * ```typescript\n * const text = buildImportStatement(\"./x\", void 0, [\"a\"]);\n * void text;\n * ```\n */\nfunction buildImportStatement(\n  moduleSpecifier: string,\n  defaultImportName: string | undefined,\n  names: readonly string[],\n): string {\n  const moduleText = JSON.stringify(moduleSpecifier);\n  const namedText = `{ ${names.join(\", \")} }`;\n  return defaultImportName === void 0\n    ? `import ${namedText} from ${moduleText};`\n    : `import ${defaultImportName}, ${namedText} from ${moduleText};`;\n}\n\n/**\n * Builds an import update fix when an existing import is compatible.\n * @param match Autofix context produced by the matcher.\n * @param sortedNames Sorted names that must be imported.\n * @param fixer ESLint fixer.\n * @returns A single replacement fix when an import can be updated.\n * @example\n * ```typescript\n * const fix = buildImportUpdateFix({ importPlan: { moduleSpecifier: \"./x\", names: [] } } as never, [], {} as never);\n * void fix;\n * ```\n */\nfunction buildImportUpdateFix(\n  match: RuleMatch,\n  sortedNames: string[],\n  fixer: Rule.RuleFixer,\n): Rule.Fix | undefined {\n  const { update } = match.importPlan;\n  if (update === void 0) {\n    return void 0;\n  }\n\n  const { moduleSpecifier } = match.importPlan;\n  const mergedNames = [\n    ...new Set([...sortedNames, ...update.existingNamedImports]),\n  ].toSorted();\n  const statementText = buildImportStatement(\n    moduleSpecifier,\n    update.defaultImportName,\n    mergedNames,\n  );\n  return fixer.replaceTextRange(update.range, statementText);\n}\n\n/**\n * Builds fixes for `mock*` member-expression object rewrites.\n * @param match Autofix context produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns Replacements for member-expression object identifiers.\n * @example\n * ```typescript\n * const fixes = buildMemberRewriteFixes({} as never, {} as never);\n * void fixes;\n * ```\n */\nfunction buildMemberRewriteFixes(\n  match: RuleMatch,\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  return match.memberRewrites.map((rewrite) =>\n    fixer.replaceTextRange(\n      rewrite.localObjectRange,\n      `vi.mocked(${rewrite.exportedName})`,\n    ),\n  );\n}\n\n/**\n * Builds a fix that converts literal mock specifiers to `import(\"...\")`.\n * @param match Autofix context produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns Fixes that normalize the mock specifier argument.\n * @example\n * ```typescript\n * const fixes = buildMockSpecifierFixes({} as never, {} as never);\n * void fixes;\n * ```\n */\nfunction buildMockSpecifierFixes(\n  match: RuleMatch,\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  if (match.mockSpecifierIsImportExpression) {\n    return [];\n  }\n\n  const moduleText = JSON.stringify(match.moduleSpecifier);\n  return [\n    fixer.replaceTextRange(match.mockSpecifierRange, `import(${moduleText})`),\n  ];\n}\n\n/**\n * Builds fixes that remove declarations after inlining.\n * @param match Autofix context produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns Fixes that remove redundant declaration statements.\n * @example\n * ```typescript\n * const fixes = buildRemovalFixes({} as never, {} as never);\n * void fixes;\n * ```\n */\nfunction buildRemovalFixes(\n  match: RuleMatch,\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  const uniqueRanges = getUniqueStatementRanges(match);\n  return uniqueRanges.map((statementRange) => {\n    const expandedRange = extendRangeToLineBreak(\n      match.sourceText,\n      statementRange,\n    );\n    return fixer.removeRange(expandedRange);\n  });\n}\n\n/**\n * Extends a statement range to include the trailing line break.\n * @param sourceText Full file content for newline lookup.\n * @param statementRange Start/end offsets for the statement.\n * @returns Statement range extended through the trailing line break.\n * @example\n * ```typescript\n * const range = extendRangeToLineBreak(\"a\\n\", [0, 1]);\n * void range;\n * ```\n */\nfunction extendRangeToLineBreak(\n  sourceText: string,\n  statementRange: Range,\n): Range {\n  const [start, end] = statementRange;\n  const nextLineFeedIndex = sourceText.indexOf(\"\\n\", end);\n  return nextLineFeedIndex === -1\n    ? [start, sourceText.length]\n    : [start, nextLineFeedIndex + 1];\n}\n\n/**\n * Returns sorted unique statement ranges for declarations to remove.\n * @param match Autofix context produced by the matcher.\n * @returns Distinct declaration statement ranges to remove.\n * @example\n * ```typescript\n * const ranges = getUniqueStatementRanges({ bindings: [], declarations: new Map() } as never);\n * void ranges;\n * ```\n */\nfunction getUniqueStatementRanges(match: RuleMatch): Range[] {\n  const rangeMap = new Map<string, Range>();\n  for (const binding of match.bindings) {\n    const declaration = match.declarations.get(binding.localName);\n    if (declaration !== void 0) {\n      const key = `${declaration.statementRange[0]}:${declaration.statementRange[1]}`;\n      rangeMap.set(key, declaration.statementRange);\n    }\n  }\n\n  return [...rangeMap.values()];\n}\n\nexport { buildFix };\n"]}

package/dist/testing/prefer-vi-mocked-import/index.d.ts

@@ -0,0 +1,2 @@
+export { preferViMockedImportRule } from "./rule";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/prefer-vi-mocked-import/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/prefer-vi-mocked-import/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/prefer-vi-mocked-import/index.js

@@ -0,0 +1,2 @@
+export { preferViMockedImportRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdGluZy9wcmVmZXItdmktbW9ja2VkLWltcG9ydC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBwcmVmZXJWaU1vY2tlZEltcG9ydFJ1bGUgfSBmcm9tIFwiLi9ydWxlXCI7XG4iXX0=