@codeperfect/eslint-plugin 1.0.0 → 2.0.0

package/dist/domain/testing/prefer-vi-mocked-import/match.js

@@ -0,0 +1,198 @@
+import { collectBindings } from "./match-bindings.js";
+import { collectDeclarations } from "./match-declarations.js";
+import { getFactoryReturnObject, getModuleSpecifier, getNewline, hasRange, } from "./match-helpers.js";
+import { resolveImportPlan } from "./match-imports.js";
+import { areLocalsSafeToInline, buildAllowedRanges, collectMemberRewrites, } from "./match-rewrites.js";
+/**
+ * Builds a full rule match from seed data.
+ * @param context Rule context.
+ * @param program Program node.
+ * @param seed Seed data.
+ * @returns Rule match when safe.
+ * @example
+ * ```typescript
+ * const match = buildMatch({ sourceCode: { text: "" } } as never, { body: [], sourceType: "module", type: "Program" } as never, { factoryObject: { properties: [], type: "ObjectExpression" }, mockStatement: { expression: { arguments: [], type: "CallExpression" }, type: "ExpressionStatement" }, moduleSpecifier: "./x", specifierExpression: { range: [0, 1], type: "Literal", value: "./x" } as never });
+ * void match;
+ * ```
+ */
+function buildMatch(context, program, seed) {
+    const declarations = collectDeclarations(program, context.sourceCode);
+    const bindings = collectBindings(seed.factoryObject, declarations);
+    if (bindings.length === 0) {
+        return void 0;
+    }
+    const memberRewrites = collectMemberRewrites(program, toLocalMap(bindings));
+    const localNames = new Set(bindings.map((binding) => binding.localName));
+    const allowedRanges = buildAllowedRanges(bindings, declarations, memberRewrites);
+    if (!areLocalsSafeToInline(program, allowedRanges, localNames)) {
+        return void 0;
+    }
+    return {
+        bindings,
+        declarations,
+        importPlan: resolveImportPlan(program, seed.moduleSpecifier, getImportNames(bindings)),
+        memberRewrites,
+        mockSpecifierIsImportExpression: seed.specifierExpression.type === "ImportExpression",
+        mockSpecifierRange: seed.specifierExpression.range,
+        moduleSpecifier: seed.moduleSpecifier,
+        newline: getNewline(context.sourceCode.text),
+        node: seed.mockStatement,
+        sourceText: context.sourceCode.text,
+    };
+}
+/**
+ * Collects the first applicable rule match from the file.
+ * @param context Rule context.
+ * @returns Collected match when pattern is found.
+ * @example
+ * ```typescript
+ * const match = collectMatch({ sourceCode: { ast: { body: [], sourceType: "module", type: "Program" }, text: "" } } as never);
+ * void match;
+ * ```
+ */
+function collectMatch(context) {
+    return collectMatches(context)[0];
+}
+/**
+ * Collects every applicable rule match from the file.
+ * @param context Rule context.
+ * @returns Collected matches when patterns are found.
+ * @example
+ * ```typescript
+ * const matches = collectMatches({ sourceCode: { ast: { body: [], sourceType: "module", type: "Program" }, text: "" } } as never);
+ * void matches;
+ * ```
+ */
+function collectMatches(context) {
+    const program = context.sourceCode.ast;
+    return collectSeeds(program)
+        .map((seed) => buildMatch(context, program, seed))
+        .filter((match) => match !== void 0);
+}
+/**
+ * Collects seed data for every supported mock statement in the file.
+ * @param program Program node.
+ * @returns Match seeds.
+ * @example
+ * ```typescript
+ * const seeds = collectSeeds({ body: [], sourceType: "module", type: "Program" } as never);
+ * void seeds;
+ * ```
+ */
+function collectSeeds(program) {
+    if (!Array.isArray(program.body)) {
+        return [];
+    }
+    return program.body.flatMap((statement) => {
+        const expression = getMockCallExpression(statement);
+        if (expression === void 0) {
+            return [];
+        }
+        const callArguments = getMockCallArguments(expression);
+        if (callArguments === void 0) {
+            return [];
+        }
+        const seed = createSeed(statement, callArguments[0], callArguments[1]);
+        return seed === void 0 ? [] : [seed];
+    });
+}
+/**
+ * Creates seed data from validated call arguments.
+ * @param mockStatement Matched `vi.mock` statement.
+ * @param specifierExpression First argument expression.
+ * @param factoryExpression Factory callback expression.
+ * @returns Match seed when arguments are supported.
+ * @example
+ * ```typescript
+ * const seed = createSeed({ expression: { arguments: [], type: "CallExpression" }, type: "ExpressionStatement" } as never, { type: "Literal", value: "./x" } as never, { body: { properties: [], type: "ObjectExpression" }, type: "ArrowFunctionExpression" } as never);
+ * void seed;
+ * ```
+ */
+function createSeed(mockStatement, specifierExpression, factoryExpression) {
+    if (!hasRange(specifierExpression)) {
+        return void 0;
+    }
+    const moduleSpecifier = getModuleSpecifier(specifierExpression);
+    const factoryObject = getFactoryReturnObject(factoryExpression);
+    return moduleSpecifier === void 0 || factoryObject === void 0
+        ? void 0
+        : { factoryObject, mockStatement, moduleSpecifier, specifierExpression };
+}
+/**
+ * Returns sorted unique import names from bindings.
+ * @param bindings Bindings list.
+ * @returns Sorted import names.
+ * @example
+ * ```typescript
+ * const names = getImportNames([]);
+ * void names;
+ * ```
+ */
+function getImportNames(bindings) {
+    return [
+        ...new Set(bindings.map((binding) => binding.exportedName)),
+    ].toSorted();
+}
+/**
+ * Returns mock call arguments when both arguments are supported expressions.
+ * @param expression Call expression node.
+ * @returns First and second call arguments.
+ * @example
+ * ```typescript
+ * const args = getMockCallArguments({ arguments: [], type: "CallExpression" } as never);
+ * void args;
+ * ```
+ */
+function getMockCallArguments(expression) {
+    const [firstArgument, secondArgument] = expression.arguments;
+    if (firstArgument === void 0 || secondArgument === void 0) {
+        return void 0;
+    }
+    if (firstArgument.type === "SpreadElement" ||
+        secondArgument.type === "SpreadElement") {
+        return void 0;
+    }
+    return [firstArgument, secondArgument];
+}
+/**
+ * Returns the call expression for a supported mock statement.
+ * @param statement Candidate statement.
+ * @returns Supported mock call expression when present.
+ * @example
+ * ```typescript
+ * const expression = getMockCallExpression({ type: "EmptyStatement" } as never);
+ * void expression;
+ * ```
+ */
+function getMockCallExpression(statement) {
+    if (statement.type !== "ExpressionStatement") {
+        return void 0;
+    }
+    const { expression } = statement;
+    if (expression.type !== "CallExpression" ||
+        expression.callee.type !== "MemberExpression") {
+        return void 0;
+    }
+    const { object, property } = expression.callee;
+    return object.type === "Identifier" &&
+        object.name === "vi" &&
+        property.type === "Identifier" &&
+        (property.name === "mock" || property.name === "doMock")
+        ? expression
+        : void 0;
+}
+/**
+ * Creates local-to-exported mapping from bindings.
+ * @param bindings Bindings list.
+ * @returns Mapping used for rewrite lookup.
+ * @example
+ * ```typescript
+ * const map = toLocalMap([]);
+ * void map;
+ * ```
+ */
+function toLocalMap(bindings) {
+    return new Map(bindings.map((binding) => [binding.localName, binding.exportedName]));
+}
+export { collectMatch, collectMatches };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport type { RuleMatch } from \"./types\";\n\nimport { collectBindings } from \"./match-bindings\";\nimport { collectDeclarations } from \"./match-declarations\";\nimport {\n  getFactoryReturnObject,\n  getModuleSpecifier,\n  getNewline,\n  hasRange,\n} from \"./match-helpers\";\nimport { resolveImportPlan } from \"./match-imports\";\nimport {\n  areLocalsSafeToInline,\n  buildAllowedRanges,\n  collectMemberRewrites,\n} from \"./match-rewrites\";\n\n/** Type definition for rule data. */\ninterface MatchSeed {\n  /** Returned object expression from the mock factory. */\n  factoryObject: ESTree.ObjectExpression;\n\n  /** Expression statement containing `vi.mock` or `vi.doMock`. */\n  mockStatement: ESTree.ExpressionStatement;\n\n  /** Module path string extracted from the first mock argument. */\n  moduleSpecifier: string;\n\n  /** Original first argument node, including `range`, for fixer use. */\n  specifierExpression: ESTree.Expression & {\n    /** Source range for the mock specifier expression. */\n    range: [number, number];\n  };\n}\n\n/**\n * Builds a full rule match from seed data.\n * @param context Rule context.\n * @param program Program node.\n * @param seed Seed data.\n * @returns Rule match when safe.\n * @example\n * ```typescript\n * const match = buildMatch({ sourceCode: { text: \"\" } } as never, { body: [], sourceType: \"module\", type: \"Program\" } as never, { factoryObject: { properties: [], type: \"ObjectExpression\" }, mockStatement: { expression: { arguments: [], type: \"CallExpression\" }, type: \"ExpressionStatement\" }, moduleSpecifier: \"./x\", specifierExpression: { range: [0, 1], type: \"Literal\", value: \"./x\" } as never });\n * void match;\n * ```\n */\nfunction buildMatch(\n  context: Rule.RuleContext,\n  program: ESTree.Program,\n  seed: MatchSeed,\n): RuleMatch | undefined {\n  const declarations = collectDeclarations(program, context.sourceCode);\n  const bindings = collectBindings(seed.factoryObject, declarations);\n  if (bindings.length === 0) {\n    return void 0;\n  }\n\n  const memberRewrites = collectMemberRewrites(program, toLocalMap(bindings));\n  const localNames = new Set(bindings.map((binding) => binding.localName));\n  const allowedRanges = buildAllowedRanges(\n    bindings,\n    declarations,\n    memberRewrites,\n  );\n  if (!areLocalsSafeToInline(program, allowedRanges, localNames)) {\n    return void 0;\n  }\n\n  return {\n    bindings,\n    declarations,\n    importPlan: resolveImportPlan(\n      program,\n      seed.moduleSpecifier,\n      getImportNames(bindings),\n    ),\n    memberRewrites,\n    mockSpecifierIsImportExpression:\n      seed.specifierExpression.type === \"ImportExpression\",\n    mockSpecifierRange: seed.specifierExpression.range,\n    moduleSpecifier: seed.moduleSpecifier,\n    newline: getNewline(context.sourceCode.text),\n    node: seed.mockStatement as unknown as Rule.Node,\n    sourceText: context.sourceCode.text,\n  };\n}\n\n/**\n * Collects the first applicable rule match from the file.\n * @param context Rule context.\n * @returns Collected match when pattern is found.\n * @example\n * ```typescript\n * const match = collectMatch({ sourceCode: { ast: { body: [], sourceType: \"module\", type: \"Program\" }, text: \"\" } } as never);\n * void match;\n * ```\n */\nfunction collectMatch(context: Rule.RuleContext): RuleMatch | undefined {\n  return collectMatches(context)[0];\n}\n\n/**\n * Collects every applicable rule match from the file.\n * @param context Rule context.\n * @returns Collected matches when patterns are found.\n * @example\n * ```typescript\n * const matches = collectMatches({ sourceCode: { ast: { body: [], sourceType: \"module\", type: \"Program\" }, text: \"\" } } as never);\n * void matches;\n * ```\n */\nfunction collectMatches(context: Rule.RuleContext): RuleMatch[] {\n  const program = context.sourceCode.ast as ESTree.Program;\n\n  return collectSeeds(program)\n    .map((seed) => buildMatch(context, program, seed))\n    .filter((match): match is RuleMatch => match !== void 0);\n}\n\n/**\n * Collects seed data for every supported mock statement in the file.\n * @param program Program node.\n * @returns Match seeds.\n * @example\n * ```typescript\n * const seeds = collectSeeds({ body: [], sourceType: \"module\", type: \"Program\" } as never);\n * void seeds;\n * ```\n */\nfunction collectSeeds(program: ESTree.Program): MatchSeed[] {\n  if (!Array.isArray(program.body)) {\n    return [];\n  }\n\n  return program.body.flatMap((statement) => {\n    const expression = getMockCallExpression(statement);\n\n    if (expression === void 0) {\n      return [];\n    }\n\n    const callArguments = getMockCallArguments(expression);\n\n    if (callArguments === void 0) {\n      return [];\n    }\n\n    const seed = createSeed(\n      statement as ESTree.ExpressionStatement,\n      callArguments[0],\n      callArguments[1],\n    );\n\n    return seed === void 0 ? [] : [seed];\n  });\n}\n\n/**\n * Creates seed data from validated call arguments.\n * @param mockStatement Matched `vi.mock` statement.\n * @param specifierExpression First argument expression.\n * @param factoryExpression Factory callback expression.\n * @returns Match seed when arguments are supported.\n * @example\n * ```typescript\n * const seed = createSeed({ expression: { arguments: [], type: \"CallExpression\" }, type: \"ExpressionStatement\" } as never, { type: \"Literal\", value: \"./x\" } as never, { body: { properties: [], type: \"ObjectExpression\" }, type: \"ArrowFunctionExpression\" } as never);\n * void seed;\n * ```\n */\nfunction createSeed(\n  mockStatement: ESTree.ExpressionStatement,\n  specifierExpression: ESTree.Expression,\n  factoryExpression: ESTree.Expression,\n): MatchSeed | undefined {\n  if (!hasRange(specifierExpression)) {\n    return void 0;\n  }\n\n  const moduleSpecifier = getModuleSpecifier(specifierExpression);\n  const factoryObject = getFactoryReturnObject(factoryExpression);\n  return moduleSpecifier === void 0 || factoryObject === void 0\n    ? void 0\n    : { factoryObject, mockStatement, moduleSpecifier, specifierExpression };\n}\n\n/**\n * Returns sorted unique import names from bindings.\n * @param bindings Bindings list.\n * @returns Sorted import names.\n * @example\n * ```typescript\n * const names = getImportNames([]);\n * void names;\n * ```\n */\nfunction getImportNames(bindings: RuleMatch[\"bindings\"]): string[] {\n  return [\n    ...new Set(bindings.map((binding) => binding.exportedName)),\n  ].toSorted();\n}\n\n/**\n * Returns mock call arguments when both arguments are supported expressions.\n * @param expression Call expression node.\n * @returns First and second call arguments.\n * @example\n * ```typescript\n * const args = getMockCallArguments({ arguments: [], type: \"CallExpression\" } as never);\n * void args;\n * ```\n */\nfunction getMockCallArguments(\n  expression: ESTree.CallExpression,\n): [ESTree.Expression, ESTree.Expression] | undefined {\n  const [firstArgument, secondArgument] = expression.arguments;\n  if (firstArgument === void 0 || secondArgument === void 0) {\n    return void 0;\n  }\n  if (\n    firstArgument.type === \"SpreadElement\" ||\n    secondArgument.type === \"SpreadElement\"\n  ) {\n    return void 0;\n  }\n\n  return [firstArgument, secondArgument];\n}\n\n/**\n * Returns the call expression for a supported mock statement.\n * @param statement Candidate statement.\n * @returns Supported mock call expression when present.\n * @example\n * ```typescript\n * const expression = getMockCallExpression({ type: \"EmptyStatement\" } as never);\n * void expression;\n * ```\n */\nfunction getMockCallExpression(\n  statement: ESTree.Program[\"body\"][number],\n): ESTree.CallExpression | undefined {\n  if (statement.type !== \"ExpressionStatement\") {\n    return void 0;\n  }\n\n  const { expression } = statement;\n  if (\n    expression.type !== \"CallExpression\" ||\n    expression.callee.type !== \"MemberExpression\"\n  ) {\n    return void 0;\n  }\n\n  const { object, property } = expression.callee;\n  return object.type === \"Identifier\" &&\n    object.name === \"vi\" &&\n    property.type === \"Identifier\" &&\n    (property.name === \"mock\" || property.name === \"doMock\")\n    ? expression\n    : void 0;\n}\n\n/**\n * Creates local-to-exported mapping from bindings.\n * @param bindings Bindings list.\n * @returns Mapping used for rewrite lookup.\n * @example\n * ```typescript\n * const map = toLocalMap([]);\n * void map;\n * ```\n */\nfunction toLocalMap(bindings: RuleMatch[\"bindings\"]): Map<string, string> {\n  return new Map(\n    bindings.map(\n      (binding) => [binding.localName, binding.exportedName] as const,\n    ),\n  );\n}\n\nexport { collectMatch, collectMatches };\n"]}

package/dist/domain/testing/prefer-vi-mocked-import/rule-test-helpers.d.ts

@@ -0,0 +1,20 @@
+import { Linter } from "eslint";
+/** Type definition for rule data. */
+interface FixRunResult {
+    /** Lint messages produced during the run. */
+    messages: Linter.LintMessage[];
+    /** Output code after fixes. */
+    output: string;
+}
+/**
+ * Runs the prefer-vi-mocked-import rule with autofix enabled.
+ * @param code Input code.
+ * @returns Fixed output and messages.
+ * @example
+ * ```typescript
+ * const result = runFix("const value = 1;\n");
+ * ```
+ */
+declare const runFix: (code: string) => FixRunResult;
+export { runFix };
+//# sourceMappingURL=rule-test-helpers.d.ts.map

package/dist/domain/testing/prefer-vi-mocked-import/rule-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-test-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/rule-test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,qCAAqC;AACrC,UAAU,YAAY;IACpB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC;IAE/B,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,MAAM,GAAI,MAAM,MAAM,KAAG,YA8B9B,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/domain/testing/prefer-vi-mocked-import/rule-test-helpers.js

@@ -0,0 +1,39 @@
+import { Linter } from "eslint";
+import { parser } from "typescript-eslint";
+import { preferViMockedImportRule } from "./rule.js";
+/**
+ * Runs the prefer-vi-mocked-import rule with autofix enabled.
+ * @param code Input code.
+ * @returns Fixed output and messages.
+ * @example
+ * ```typescript
+ * const result = runFix("const value = 1;\n");
+ * ```
+ */
+const runFix = (code) => {
+    const linter = new Linter({ configType: "flat" });
+    const result = linter.verifyAndFix(code, [
+        {
+            files: ["**/*.ts"],
+            languageOptions: {
+                ecmaVersion: 2022,
+                parser,
+                parserOptions: { range: true },
+                sourceType: "module",
+            },
+            plugins: {
+                codeperfect: {
+                    rules: {
+                        "prefer-vi-mocked-import": preferViMockedImportRule,
+                    },
+                },
+            },
+            rules: {
+                "codeperfect/prefer-vi-mocked-import": "error",
+            },
+        },
+    ], { filename: "example.spec.ts" });
+    return { messages: result.messages, output: result.output };
+};
+export { runFix };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAMnC,6EAA6E;AAC7E,QAAA,MAAM,wBAAwB,EAAE,IAAI,CAAC,UAqCpC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/domain/testing/prefer-vi-mocked-import/rule.js

@@ -0,0 +1,36 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { buildFixes } from "./fix.js";
+import { collectMatches } from "./match.js";
+/** Enforce inline `vi.fn()` mocks inside `vi.mock`/`vi.doMock` factories. */
+const preferViMockedImportRule = {
+    create(context) {
+        return {
+            Program: () => {
+                const matches = collectMatches(context);
+                if (matches.length === 0) {
+                    return;
+                }
+                for (const [index, match] of matches.entries()) {
+                    context.report({
+                        fix: index === 0
+                            ? (fixer) => buildFixes(matches, fixer)
+                            : void 0,
+                        messageId: "preferViMockedImport",
+                        node: match.node,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("prefer-vi-mocked-import", "Prefer inlining vi.fn mocks in vi.mock/vi.doMock factories and using vi.mocked(...)."),
+        fixable: "code",
+        messages: {
+            preferViMockedImport: "Inline vi.fn mocks in the vi.mock/vi.doMock factory and use vi.mocked(...) for calls.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { preferViMockedImportRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{testing → domain/testing}/prefer-vi-mocked-import/types.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { Range } from "./match-helpers";
+import type { Range } from "./match-helpers.js";
 /** Type definition for rule data. */
 interface Binding {
     /** Name of the mocked export (object property key). */

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,qCAAqC;AACrC,UAAU,OAAO;IACf,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAC;IAErB,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAElB,mDAAmD;IACnD,gBAAgB,EAAE,KAAK,CAAC;IAExB,oDAAoD;IACpD,aAAa,EAAE,KAAK,CAAC;IAErB,kEAAkE;IAClE,kBAAkB,EAAE,KAAK,CAAC;CAC3B;AAED,qCAAqC;AACrC,UAAU,WAAW;IACnB,4EAA4E;IAC5E,kBAAkB,EAAE,KAAK,CAAC;IAE1B,mEAAmE;IACnE,gBAAgB,EAAE,KAAK,CAAC;IAExB,2BAA2B;IAC3B,SAAS,EAAE,MAAM,CAAC;IAElB,6CAA6C;IAC7C,cAAc,EAAE,KAAK,CAAC;CACvB;AAED,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,wDAAwD;IACxD,UAAU,CAAC,EAAE,KAAK,CAAC;CACpB;AAED,qCAAqC;AACrC,UAAU,UAAU;IAClB,oDAAoD;IACpD,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAE1B,uCAAuC;IACvC,eAAe,EAAE,MAAM,CAAC;IAExB,mDAAmD;IACnD,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,8CAA8C;IAC9C,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAE/B,gDAAgD;IAChD,KAAK,EAAE,KAAK,CAAC;CACd;AAED,qCAAqC;AACrC,UAAU,aAAa;IACrB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IAErB,oEAAoE;IACpE,gBAAgB,EAAE,KAAK,CAAC;CACzB;AAED,qCAAqC;AACrC,UAAU,SAAS;IACjB,0DAA0D;IAC1D,QAAQ,EAAE,OAAO,EAAE,CAAC;IAEpB,kCAAkC;IAClC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAEvC,oCAAoC;IACpC,UAAU,EAAE,UAAU,CAAC;IAEvB,qDAAqD;IACrD,cAAc,EAAE,aAAa,EAAE,CAAC;IAEhC,+DAA+D;IAC/D,+BAA+B,EAAE,OAAO,CAAC;IAEzC,4DAA4D;IAC5D,kBAAkB,EAAE,KAAK,CAAC;IAE1B,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IAExB,mDAAmD;IACnD,OAAO,EAAE,IAAI,GAAG,MAAM,CAAC;IAEvB,iCAAiC;IACjC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAEhB,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC"}

package/dist/domain/testing/prefer-vi-mocked-import/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/prefer-vitest-incremental-casts/ast-helpers.d.ts

@@ -0,0 +1,86 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import type { ShorthandContext, SupportedProperty } from "./types.js";
+/**
+ * Checks whether a property can remain in shorthand form after replacement.
+ * @param context Property shorthand decision context.
+ * @returns True when shorthand syntax remains valid.
+ * @example
+ * ```typescript
+ * const keepShorthand = canUseShorthand(context);
+ * ```
+ */
+declare function canUseShorthand(context: ShorthandContext): boolean;
+/**
+ * Resolves the expression returned by the mock factory.
+ * @param factoryArgument Mock factory function expression.
+ * @returns Returned expression when one is present.
+ * @example
+ * ```typescript
+ * const returnExpression = getFactoryReturnExpression(factoryArgument);
+ * ```
+ */
+declare function getFactoryReturnExpression(factoryArgument: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression): TSESTree.Expression | undefined;
+/**
+ * Extracts the module specifier from a mock call argument.
+ * @param moduleArgument Import expression or string literal argument.
+ * @returns Static module specifier when it can be determined.
+ * @example
+ * ```typescript
+ * const moduleSpecifier = getModuleSpecifier(moduleArgument);
+ * ```
+ */
+declare function getModuleSpecifier(moduleArgument: TSESTree.Expression): string | undefined;
+/**
+ * Converts an object property key node into a stable string name.
+ * @param propertyKey Property key node from the object literal.
+ * @returns Property name when the key is statically known.
+ * @example
+ * ```typescript
+ * const propertyName = getPropertyName(property.key);
+ * ```
+ */
+declare function getPropertyName(propertyKey: TSESTree.PropertyName): string | undefined;
+/**
+ * Narrows object literal elements to the subset the fixer can rewrite safely.
+ * @param property Object literal element to inspect.
+ * @returns True when the property is supported by the fixer.
+ * @example
+ * ```typescript
+ * const supported = isSupportedProperty(property);
+ * ```
+ */
+declare function isSupportedProperty(property: TSESTree.ObjectLiteralElement): property is SupportedProperty;
+/**
+ * Detects `vi.mock(...)` and `vi.doMock(...)` calls.
+ * @param node Call expression being inspected.
+ * @returns True when the call targets a Vitest mock factory.
+ * @example
+ * ```typescript
+ * const isMockCall = isVitestMockCall(callExpression);
+ * ```
+ */
+declare function isVitestMockCall(node: TSESTree.CallExpression): boolean;
+/**
+ * Determines whether the fixed object literal must be parenthesized.
+ * @param factoryArgument Mock factory function expression.
+ * @param returnExpression Expression returned by the factory.
+ * @param objectExpression Object literal being rewritten.
+ * @returns True when parentheses are required around the object literal.
+ * @example
+ * ```typescript
+ * const wrapObject = shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression);
+ * ```
+ */
+declare function shouldWrapImplicitObject(factoryArgument: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression, returnExpression: TSESTree.Expression, objectExpression: TSESTree.ObjectExpression): boolean;
+/**
+ * Removes surrounding cast wrappers from an expression.
+ * @param expression Expression to unwrap.
+ * @returns The innermost non-cast expression.
+ * @example
+ * ```typescript
+ * const baseExpression = unwrapExpression(expression);
+ * ```
+ */
+declare function unwrapExpression(expression: TSESTree.Expression): TSESTree.Expression;
+export { canUseShorthand, getFactoryReturnExpression, getModuleSpecifier, getPropertyName, isSupportedProperty, isVitestMockCall, shouldWrapImplicitObject, unwrapExpression, };
+//# sourceMappingURL=ast-helpers.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/ast-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/ast-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;GAQG;AACH,iBAAS,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAU3D;AAED;;;;;;;;GAQG;AACH,iBAAS,0BAA0B,CACjC,eAAe,EACX,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,kBAAkB,GAC9B,QAAQ,CAAC,UAAU,GAAG,SAAS,CAYjC;AAED;;;;;;;;GAQG;AACH,iBAAS,kBAAkB,CACzB,cAAc,EAAE,QAAQ,CAAC,UAAU,GAClC,MAAM,GAAG,SAAS,CAkBpB;AAED;;;;;;;;GAQG;AACH,iBAAS,eAAe,CACtB,WAAW,EAAE,QAAQ,CAAC,YAAY,GACjC,MAAM,GAAG,SAAS,CAapB;AAED;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAC1B,QAAQ,EAAE,QAAQ,CAAC,oBAAoB,GACtC,QAAQ,IAAI,iBAAiB,CAQ/B;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,cAAc,GAAG,OAAO,CAahE;AAED;;;;;;;;;;GAUG;AACH,iBAAS,wBAAwB,CAC/B,eAAe,EACX,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,kBAAkB,EAC/B,gBAAgB,EAAE,QAAQ,CAAC,UAAU,EACrC,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB,GAC1C,OAAO,CAMT;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CACvB,UAAU,EAAE,QAAQ,CAAC,UAAU,GAC9B,QAAQ,CAAC,UAAU,CAYrB;AAED,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,EACxB,gBAAgB,GACjB,CAAC"}

package/dist/domain/testing/prefer-vitest-incremental-casts/ast-helpers.js

@@ -0,0 +1,150 @@
+import { TSESTree } from "@typescript-eslint/utils";
+/**
+ * Checks whether a property can remain in shorthand form after replacement.
+ * @param context Property shorthand decision context.
+ * @returns True when shorthand syntax remains valid.
+ * @example
+ * ```typescript
+ * const keepShorthand = canUseShorthand(context);
+ * ```
+ */
+function canUseShorthand(context) {
+    const { baseValue, keyName, needsCast, property } = context;
+    return (!needsCast &&
+        baseValue.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        property.key.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        property.key.name === keyName &&
+        baseValue.name === keyName);
+}
+/**
+ * Resolves the expression returned by the mock factory.
+ * @param factoryArgument Mock factory function expression.
+ * @returns Returned expression when one is present.
+ * @example
+ * ```typescript
+ * const returnExpression = getFactoryReturnExpression(factoryArgument);
+ * ```
+ */
+function getFactoryReturnExpression(factoryArgument) {
+    if (factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement) {
+        return factoryArgument.body;
+    }
+    const returnStatement = factoryArgument.body.body.find((statement) => statement.type === TSESTree.AST_NODE_TYPES.ReturnStatement &&
+        statement.argument !== null);
+    return returnStatement?.argument ?? void 0;
+}
+/**
+ * Extracts the module specifier from a mock call argument.
+ * @param moduleArgument Import expression or string literal argument.
+ * @returns Static module specifier when it can be determined.
+ * @example
+ * ```typescript
+ * const moduleSpecifier = getModuleSpecifier(moduleArgument);
+ * ```
+ */
+function getModuleSpecifier(moduleArgument) {
+    if (moduleArgument.type === TSESTree.AST_NODE_TYPES.ImportExpression) {
+        const { source } = moduleArgument;
+        if (source.type === TSESTree.AST_NODE_TYPES.Literal &&
+            typeof source.value === "string") {
+            return source.value;
+        }
+        return void 0;
+    }
+    return moduleArgument.type === TSESTree.AST_NODE_TYPES.Literal &&
+        typeof moduleArgument.value === "string"
+        ? moduleArgument.value
+        : void 0;
+}
+/**
+ * Converts an object property key node into a stable string name.
+ * @param propertyKey Property key node from the object literal.
+ * @returns Property name when the key is statically known.
+ * @example
+ * ```typescript
+ * const propertyName = getPropertyName(property.key);
+ * ```
+ */
+function getPropertyName(propertyKey) {
+    if (propertyKey.type === TSESTree.AST_NODE_TYPES.Identifier) {
+        return propertyKey.name;
+    }
+    if (propertyKey.type === TSESTree.AST_NODE_TYPES.Literal) {
+        return typeof propertyKey.value === "string" ||
+            typeof propertyKey.value === "number"
+            ? String(propertyKey.value)
+            : void 0;
+    }
+    return void 0;
+}
+/**
+ * Narrows object literal elements to the subset the fixer can rewrite safely.
+ * @param property Object literal element to inspect.
+ * @returns True when the property is supported by the fixer.
+ * @example
+ * ```typescript
+ * const supported = isSupportedProperty(property);
+ * ```
+ */
+function isSupportedProperty(property) {
+    return (property.type === TSESTree.AST_NODE_TYPES.Property &&
+        !property.computed &&
+        property.kind === "init" &&
+        !property.method &&
+        property.value.type !== TSESTree.AST_NODE_TYPES.AssignmentPattern);
+}
+/**
+ * Detects `vi.mock(...)` and `vi.doMock(...)` calls.
+ * @param node Call expression being inspected.
+ * @returns True when the call targets a Vitest mock factory.
+ * @example
+ * ```typescript
+ * const isMockCall = isVitestMockCall(callExpression);
+ * ```
+ */
+function isVitestMockCall(node) {
+    if (node.callee.type !== TSESTree.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const { object, property } = node.callee;
+    return (object.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        object.name === "vi" &&
+        property.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        (property.name === "mock" || property.name === "doMock"));
+}
+/**
+ * Determines whether the fixed object literal must be parenthesized.
+ * @param factoryArgument Mock factory function expression.
+ * @param returnExpression Expression returned by the factory.
+ * @param objectExpression Object literal being rewritten.
+ * @returns True when parentheses are required around the object literal.
+ * @example
+ * ```typescript
+ * const wrapObject = shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression);
+ * ```
+ */
+function shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression) {
+    return (factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement &&
+        (returnExpression.range[0] !== objectExpression.range[0] ||
+            returnExpression.range[1] !== objectExpression.range[1]));
+}
+/**
+ * Removes surrounding cast wrappers from an expression.
+ * @param expression Expression to unwrap.
+ * @returns The innermost non-cast expression.
+ * @example
+ * ```typescript
+ * const baseExpression = unwrapExpression(expression);
+ * ```
+ */
+function unwrapExpression(expression) {
+    let currentExpression = expression;
+    while (currentExpression.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||
+        currentExpression.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression ||
+        currentExpression.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion) {
+        currentExpression = currentExpression.expression;
+    }
+    return currentExpression;
+}
+export { canUseShorthand, getFactoryReturnExpression, getModuleSpecifier, getPropertyName, isSupportedProperty, isVitestMockCall, shouldWrapImplicitObject, unwrapExpression, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ast-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/ast-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { TSESTree } from \"@typescript-eslint/utils\";\r\n\r\nimport type { ShorthandContext, SupportedProperty } from \"./types\";\r\n\r\n/**\r\n * Checks whether a property can remain in shorthand form after replacement.\r\n * @param context Property shorthand decision context.\r\n * @returns True when shorthand syntax remains valid.\r\n * @example\r\n * ```typescript\r\n * const keepShorthand = canUseShorthand(context);\r\n * ```\r\n */\r\nfunction canUseShorthand(context: ShorthandContext): boolean {\r\n  const { baseValue, keyName, needsCast, property } = context;\r\n\r\n  return (\r\n    !needsCast &&\r\n    baseValue.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    property.key.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    property.key.name === keyName &&\r\n    baseValue.name === keyName\r\n  );\r\n}\r\n\r\n/**\r\n * Resolves the expression returned by the mock factory.\r\n * @param factoryArgument Mock factory function expression.\r\n * @returns Returned expression when one is present.\r\n * @example\r\n * ```typescript\r\n * const returnExpression = getFactoryReturnExpression(factoryArgument);\r\n * ```\r\n */\r\nfunction getFactoryReturnExpression(\r\n  factoryArgument:\r\n    | TSESTree.ArrowFunctionExpression\r\n    | TSESTree.FunctionExpression,\r\n): TSESTree.Expression | undefined {\r\n  if (factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement) {\r\n    return factoryArgument.body;\r\n  }\r\n\r\n  const returnStatement = factoryArgument.body.body.find(\r\n    (statement): statement is TSESTree.ReturnStatement =>\r\n      statement.type === TSESTree.AST_NODE_TYPES.ReturnStatement &&\r\n      statement.argument !== null,\r\n  );\r\n\r\n  return returnStatement?.argument ?? void 0;\r\n}\r\n\r\n/**\r\n * Extracts the module specifier from a mock call argument.\r\n * @param moduleArgument Import expression or string literal argument.\r\n * @returns Static module specifier when it can be determined.\r\n * @example\r\n * ```typescript\r\n * const moduleSpecifier = getModuleSpecifier(moduleArgument);\r\n * ```\r\n */\r\nfunction getModuleSpecifier(\r\n  moduleArgument: TSESTree.Expression,\r\n): string | undefined {\r\n  if (moduleArgument.type === TSESTree.AST_NODE_TYPES.ImportExpression) {\r\n    const { source } = moduleArgument;\r\n\r\n    if (\r\n      source.type === TSESTree.AST_NODE_TYPES.Literal &&\r\n      typeof source.value === \"string\"\r\n    ) {\r\n      return source.value;\r\n    }\r\n\r\n    return void 0;\r\n  }\r\n\r\n  return moduleArgument.type === TSESTree.AST_NODE_TYPES.Literal &&\r\n    typeof moduleArgument.value === \"string\"\r\n    ? moduleArgument.value\r\n    : void 0;\r\n}\r\n\r\n/**\r\n * Converts an object property key node into a stable string name.\r\n * @param propertyKey Property key node from the object literal.\r\n * @returns Property name when the key is statically known.\r\n * @example\r\n * ```typescript\r\n * const propertyName = getPropertyName(property.key);\r\n * ```\r\n */\r\nfunction getPropertyName(\r\n  propertyKey: TSESTree.PropertyName,\r\n): string | undefined {\r\n  if (propertyKey.type === TSESTree.AST_NODE_TYPES.Identifier) {\r\n    return propertyKey.name;\r\n  }\r\n\r\n  if (propertyKey.type === TSESTree.AST_NODE_TYPES.Literal) {\r\n    return typeof propertyKey.value === \"string\" ||\r\n      typeof propertyKey.value === \"number\"\r\n      ? String(propertyKey.value)\r\n      : void 0;\r\n  }\r\n\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Narrows object literal elements to the subset the fixer can rewrite safely.\r\n * @param property Object literal element to inspect.\r\n * @returns True when the property is supported by the fixer.\r\n * @example\r\n * ```typescript\r\n * const supported = isSupportedProperty(property);\r\n * ```\r\n */\r\nfunction isSupportedProperty(\r\n  property: TSESTree.ObjectLiteralElement,\r\n): property is SupportedProperty {\r\n  return (\r\n    property.type === TSESTree.AST_NODE_TYPES.Property &&\r\n    !property.computed &&\r\n    property.kind === \"init\" &&\r\n    !property.method &&\r\n    property.value.type !== TSESTree.AST_NODE_TYPES.AssignmentPattern\r\n  );\r\n}\r\n\r\n/**\r\n * Detects `vi.mock(...)` and `vi.doMock(...)` calls.\r\n * @param node Call expression being inspected.\r\n * @returns True when the call targets a Vitest mock factory.\r\n * @example\r\n * ```typescript\r\n * const isMockCall = isVitestMockCall(callExpression);\r\n * ```\r\n */\r\nfunction isVitestMockCall(node: TSESTree.CallExpression): boolean {\r\n  if (node.callee.type !== TSESTree.AST_NODE_TYPES.MemberExpression) {\r\n    return false;\r\n  }\r\n\r\n  const { object, property } = node.callee;\r\n\r\n  return (\r\n    object.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    object.name === \"vi\" &&\r\n    property.type === TSESTree.AST_NODE_TYPES.Identifier &&\r\n    (property.name === \"mock\" || property.name === \"doMock\")\r\n  );\r\n}\r\n\r\n/**\r\n * Determines whether the fixed object literal must be parenthesized.\r\n * @param factoryArgument Mock factory function expression.\r\n * @param returnExpression Expression returned by the factory.\r\n * @param objectExpression Object literal being rewritten.\r\n * @returns True when parentheses are required around the object literal.\r\n * @example\r\n * ```typescript\r\n * const wrapObject = shouldWrapImplicitObject(factoryArgument, returnExpression, objectExpression);\r\n * ```\r\n */\r\nfunction shouldWrapImplicitObject(\r\n  factoryArgument:\r\n    | TSESTree.ArrowFunctionExpression\r\n    | TSESTree.FunctionExpression,\r\n  returnExpression: TSESTree.Expression,\r\n  objectExpression: TSESTree.ObjectExpression,\r\n): boolean {\r\n  return (\r\n    factoryArgument.body.type !== TSESTree.AST_NODE_TYPES.BlockStatement &&\r\n    (returnExpression.range[0] !== objectExpression.range[0] ||\r\n      returnExpression.range[1] !== objectExpression.range[1])\r\n  );\r\n}\r\n\r\n/**\r\n * Removes surrounding cast wrappers from an expression.\r\n * @param expression Expression to unwrap.\r\n * @returns The innermost non-cast expression.\r\n * @example\r\n * ```typescript\r\n * const baseExpression = unwrapExpression(expression);\r\n * ```\r\n */\r\nfunction unwrapExpression(\r\n  expression: TSESTree.Expression,\r\n): TSESTree.Expression {\r\n  let currentExpression = expression;\r\n\r\n  while (\r\n    currentExpression.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||\r\n    currentExpression.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression ||\r\n    currentExpression.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion\r\n  ) {\r\n    currentExpression = currentExpression.expression;\r\n  }\r\n\r\n  return currentExpression;\r\n}\r\n\r\nexport {\r\n  canUseShorthand,\r\n  getFactoryReturnExpression,\r\n  getModuleSpecifier,\r\n  getPropertyName,\r\n  isSupportedProperty,\r\n  isVitestMockCall,\r\n  shouldWrapImplicitObject,\r\n  unwrapExpression,\r\n};\r\n"]}

package/dist/domain/testing/prefer-vitest-incremental-casts/index.d.ts

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