@codeperfect/eslint-plugin 2.1.0 → 2.3.0

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

@@ -1,188 +0,0 @@
-import { Linter } from "eslint";
-import { parser } from "typescript-eslint";
-import { vi } from "vitest";
-import { enforceAaaPhasePurityRule } from "./rule.js";
-/**
- * Creates the mocked AAA module used by the rule test helper.
- * @param mockedAnalysis Mocked analysis returned by the helper.
- * @returns Partial AAA module used for Vitest mocking.
- * @example
- * ```typescript
- * const module = createMockedAaaModule(createMockedAnalysis({ sectionComments: [], statements: [] }));
- * void module;
- * ```
- */
-function createMockedAaaModule(mockedAnalysis) {
-    return {
-        analyzeTestBlock: () => mockedAnalysis,
-        hasAssertion: () => false,
-        hasAsyncLogic: () => false,
-        hasAwait: () => false,
-        hasCapturableActResult: () => false,
-        hasMutation: () => false,
-        isMeaningfulActStatement: () => false,
-        isSetupLikeStatement: () => false,
-        isValidAssertStatement: () => false,
-    };
-}
-/**
- * Creates a full analysis object from the minimal fields used in tests.
- * @param analysis Minimal analysis input used by tests.
- * @returns Complete analysis object consumed by the rule.
- * @example
- * ```typescript
- * const result = createMockedAnalysis({ sectionComments: [], statements: [] });
- * void result;
- * ```
- */
-function createMockedAnalysis(analysis) {
-    return {
-        body: createMockedBody(),
-        bodyLineCount: 0,
-        callExpression: createMockedCallExpression(),
-        newline: "\n",
-        sectionComments: analysis.sectionComments.map((sectionComment) => ({
-            comment: {
-                loc: {
-                    end: { column: 0, line: 1 },
-                    start: { column: 0, line: 1 },
-                },
-                range: [0, 0],
-                type: "Line",
-                value: ` ${sectionComment.phases.join(" / ")}`,
-            },
-            phases: sectionComment.phases,
-        })),
-        sourceText: "",
-        statements: analysis.statements.map((statement) => ({
-            node: statement.node,
-            phase: statement.phases.at(-1),
-            phases: statement.phases,
-        })),
-    };
-}
-/**
- * Creates a minimal located block statement for mocked AAA analysis.
- * @returns Minimal located block statement.
- * @example
- * ```typescript
- * const body = createMockedBody();
- * ```
- */
-function createMockedBody() {
-    return {
-        body: [],
-        loc: {
-            end: { column: 0, line: 1 },
-            start: { column: 0, line: 1 },
-        },
-        range: [0, 0],
-        type: "BlockStatement",
-    };
-}
-/**
- * Creates a minimal located call expression for mocked AAA analysis.
- * @returns Minimal located call expression.
- * @example
- * ```typescript
- * const callExpression = createMockedCallExpression();
- * ```
- */
-function createMockedCallExpression() {
-    return {
-        arguments: [],
-        callee: { name: "it", type: "Identifier" },
-        loc: {
-            end: { column: 0, line: 1 },
-            start: { column: 0, line: 1 },
-        },
-        optional: false,
-        range: [0, 0],
-        type: "CallExpression",
-    };
-}
-/**
- * Creates the mocked rule listener used by the helper.
- * @param analysis Mocked analysis returned from `analyzeTestBlock`.
- * @param report Report spy passed into the mocked rule context.
- * @returns Call-expression listener produced by the mocked rule.
- * @example
- * ```typescript
- * const listener = await loadMockedListener({ sectionComments: [], statements: [] }, vi.fn());
- * void listener;
- * ```
- */
-async function loadMockedListener(analysis, report) {
-    vi.resetModules();
-    vi.doMock("../aaa", () => createMockedAaaModule(createMockedAnalysis(analysis)));
-    const ruleModule = await import("./rule.js");
-    return ruleModule.enforceAaaPhasePurityRule.create({ report })
-        .CallExpression;
-}
-/**
- * Resets the mocked AAA module state between test runs.
- * @example
- * ```typescript
- * resetMockedAaaModule();
- * ```
- */
-function resetMockedAaaModule() {
-    vi.doUnmock("../aaa");
-    vi.resetModules();
-}
-/**
- * Runs the rule against one source snippet.
- * @param code Source code passed to the linter.
- * @returns Lint messages produced by the rule.
- * @example
- * ```typescript
- * const messages = runRule('it("works", () => {});');
- * void messages;
- * ```
- */
-function runRule(code) {
-    const linter = new Linter({ configType: "flat" });
-    return linter.verify(code, [
-        {
-            files: ["**/*.ts"],
-            languageOptions: {
-                ecmaVersion: 2022,
-                parser,
-                sourceType: "module",
-            },
-            plugins: {
-                codeperfect: {
-                    rules: {
-                        "enforce-aaa-phase-purity": enforceAaaPhasePurityRule,
-                    },
-                },
-            },
-            rules: {
-                "codeperfect/enforce-aaa-phase-purity": "error",
-            },
-        },
-    ], "example.spec.ts");
-}
-/**
- * Runs the rule with a mocked AAA analysis result.
- * @param analysis Mocked analysis returned from `analyzeTestBlock`.
- * @returns Captured report calls issued by the rule.
- * @example
- * ```typescript
- * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });
- * void calls;
- * ```
- */
-async function runRuleWithMockedAnalysis(analysis) {
-    const report = vi.fn();
-    const listener = await loadMockedListener(analysis, report);
-    try {
-        listener?.({ type: "CallExpression" });
-        return report.mock.calls;
-    }
-    finally {
-        resetMockedAaaModule();
-    }
-}
-export { runRule, runRuleWithMockedAnalysis };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\nimport { Linter } from \"eslint\";\r\nimport { parser } from \"typescript-eslint\";\r\nimport { vi } from \"vitest\";\r\n\r\nimport type * as AaaModule from \"../aaa\";\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport { enforceAaaPhasePurityRule } from \"./rule\";\r\n\r\n/** Minimal analysis input accepted by the mocked AAA helper. */\r\ninterface MockedAnalysisInput {\r\n  /** Section comments relevant to the rule under test. */\r\n  sectionComments: {\r\n    /** Phase names declared by the synthetic comment. */\r\n    phases: TestBlockAnalysis[\"sectionComments\"][number][\"phases\"];\r\n  }[];\r\n  /** Statement metadata relevant to the rule under test. */\r\n  statements: {\r\n    /** Synthetic statement node provided to the rule. */\r\n    node: ESTree.Statement;\r\n\r\n    /** Active phases assigned to the statement. */\r\n    phases: TestBlockAnalysis[\"statements\"][number][\"phases\"];\r\n  }[];\r\n}\r\n\r\n/** Module shape returned when the rule is loaded after mocking the AAA helpers. */\r\ninterface MockedRuleModule {\r\n  /** Rule implementation under test. */\r\n  enforceAaaPhasePurityRule: typeof enforceAaaPhasePurityRule;\r\n}\r\n\r\n/**\r\n * Creates the mocked AAA module used by the rule test helper.\r\n * @param mockedAnalysis Mocked analysis returned by the helper.\r\n * @returns Partial AAA module used for Vitest mocking.\r\n * @example\r\n * ```typescript\r\n * const module = createMockedAaaModule(createMockedAnalysis({ sectionComments: [], statements: [] }));\r\n * void module;\r\n * ```\r\n */\r\nfunction createMockedAaaModule(\r\n  mockedAnalysis: TestBlockAnalysis,\r\n): Partial<typeof AaaModule> {\r\n  return {\r\n    analyzeTestBlock: (): TestBlockAnalysis => mockedAnalysis,\r\n    hasAssertion: (): boolean => false,\r\n    hasAsyncLogic: (): boolean => false,\r\n    hasAwait: (): boolean => false,\r\n    hasCapturableActResult: (): boolean => false,\r\n    hasMutation: (): boolean => false,\r\n    isMeaningfulActStatement: (): boolean => false,\r\n    isSetupLikeStatement: (): boolean => false,\r\n    isValidAssertStatement: (): boolean => false,\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a full analysis object from the minimal fields used in tests.\r\n * @param analysis Minimal analysis input used by tests.\r\n * @returns Complete analysis object consumed by the rule.\r\n * @example\r\n * ```typescript\r\n * const result = createMockedAnalysis({ sectionComments: [], statements: [] });\r\n * void result;\r\n * ```\r\n */\r\nfunction createMockedAnalysis(\r\n  analysis: MockedAnalysisInput,\r\n): TestBlockAnalysis {\r\n  return {\r\n    body: createMockedBody(),\r\n    bodyLineCount: 0,\r\n    callExpression: createMockedCallExpression(),\r\n    newline: \"\\n\",\r\n    sectionComments: analysis.sectionComments.map((sectionComment) => ({\r\n      comment: {\r\n        loc: {\r\n          end: { column: 0, line: 1 },\r\n          start: { column: 0, line: 1 },\r\n        },\r\n        range: [0, 0],\r\n        type: \"Line\",\r\n        value: ` ${sectionComment.phases.join(\" / \")}`,\r\n      },\r\n      phases: sectionComment.phases,\r\n    })),\r\n    sourceText: \"\",\r\n    statements: analysis.statements.map((statement) => ({\r\n      node: statement.node as TestBlockAnalysis[\"statements\"][number][\"node\"],\r\n      phase: statement.phases.at(-1),\r\n      phases: statement.phases,\r\n    })),\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a minimal located block statement for mocked AAA analysis.\r\n * @returns Minimal located block statement.\r\n * @example\r\n * ```typescript\r\n * const body = createMockedBody();\r\n * ```\r\n */\r\nfunction createMockedBody(): TestBlockAnalysis[\"body\"] {\r\n  return {\r\n    body: [],\r\n    loc: {\r\n      end: { column: 0, line: 1 },\r\n      start: { column: 0, line: 1 },\r\n    },\r\n    range: [0, 0],\r\n    type: \"BlockStatement\",\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a minimal located call expression for mocked AAA analysis.\r\n * @returns Minimal located call expression.\r\n * @example\r\n * ```typescript\r\n * const callExpression = createMockedCallExpression();\r\n * ```\r\n */\r\nfunction createMockedCallExpression(): TestBlockAnalysis[\"callExpression\"] {\r\n  return {\r\n    arguments: [],\r\n    callee: { name: \"it\", type: \"Identifier\" } as ESTree.Identifier,\r\n    loc: {\r\n      end: { column: 0, line: 1 },\r\n      start: { column: 0, line: 1 },\r\n    },\r\n    optional: false,\r\n    range: [0, 0],\r\n    type: \"CallExpression\",\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the mocked rule listener used by the helper.\r\n * @param analysis Mocked analysis returned from `analyzeTestBlock`.\r\n * @param report Report spy passed into the mocked rule context.\r\n * @returns Call-expression listener produced by the mocked rule.\r\n * @example\r\n * ```typescript\r\n * const listener = await loadMockedListener({ sectionComments: [], statements: [] }, vi.fn());\r\n * void listener;\r\n * ```\r\n */\r\nasync function loadMockedListener(\r\n  analysis: MockedAnalysisInput,\r\n  report: ReturnType<typeof vi.fn>,\r\n): Promise<((node: ESTree.CallExpression) => void) | undefined> {\r\n  vi.resetModules();\r\n  vi.doMock(\"../aaa\", () =>\r\n    createMockedAaaModule(createMockedAnalysis(analysis)),\r\n  );\r\n\r\n  const ruleModule: MockedRuleModule = await import(\"./rule\");\r\n\r\n  return ruleModule.enforceAaaPhasePurityRule.create({ report } as never)\r\n    .CallExpression as ((node: ESTree.CallExpression) => void) | undefined;\r\n}\r\n\r\n/**\r\n * Resets the mocked AAA module state between test runs.\r\n * @example\r\n * ```typescript\r\n * resetMockedAaaModule();\r\n * ```\r\n */\r\nfunction resetMockedAaaModule(): void {\r\n  vi.doUnmock(\"../aaa\");\r\n  vi.resetModules();\r\n}\r\n\r\n/**\r\n * Runs the rule against one source snippet.\r\n * @param code Source code passed to the linter.\r\n * @returns Lint messages produced by the rule.\r\n * @example\r\n * ```typescript\r\n * const messages = runRule('it(\"works\", () => {});');\r\n * void messages;\r\n * ```\r\n */\r\nfunction runRule(code: string): Linter.LintMessage[] {\r\n  const linter = new Linter({ configType: \"flat\" });\r\n\r\n  return linter.verify(\r\n    code,\r\n    [\r\n      {\r\n        files: [\"**/*.ts\"],\r\n        languageOptions: {\r\n          ecmaVersion: 2022,\r\n          parser,\r\n          sourceType: \"module\",\r\n        },\r\n        plugins: {\r\n          codeperfect: {\r\n            rules: {\r\n              \"enforce-aaa-phase-purity\": enforceAaaPhasePurityRule,\r\n            },\r\n          },\r\n        },\r\n        rules: {\r\n          \"codeperfect/enforce-aaa-phase-purity\": \"error\",\r\n        },\r\n      },\r\n    ],\r\n    \"example.spec.ts\",\r\n  );\r\n}\r\n\r\n/**\r\n * Runs the rule with a mocked AAA analysis result.\r\n * @param analysis Mocked analysis returned from `analyzeTestBlock`.\r\n * @returns Captured report calls issued by the rule.\r\n * @example\r\n * ```typescript\r\n * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });\r\n * void calls;\r\n * ```\r\n */\r\nasync function runRuleWithMockedAnalysis(\r\n  analysis: MockedAnalysisInput,\r\n): Promise<unknown[][]> {\r\n  const report = vi.fn();\r\n  const listener = await loadMockedListener(analysis, report);\r\n\r\n  try {\r\n    listener?.({ type: \"CallExpression\" } as ESTree.CallExpression);\r\n    return report.mock.calls as unknown[][];\r\n  } finally {\r\n    resetMockedAaaModule();\r\n  }\r\n}\r\n\r\nexport { runRule, runRuleWithMockedAnalysis };\r\n"]}

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

@@ -1,5 +0,0 @@
-import type { Rule } from "eslint";
-/** Enforces pure Arrange, Act, and Assert behavior inside AAA-marked tests. */
-declare const enforceAaaPhasePurityRule: Rule.RuleModule;
-export { enforceAaaPhasePurityRule };
-//# sourceMappingURL=rule.d.ts.map

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

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

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

@@ -1,37 +0,0 @@
-import { analyzeTestBlock } from "../aaa/index.js";
-import { reportPhasePurityViolations } from "./phase-purity-reporting.js";
-/** Enforces pure Arrange, Act, and Assert behavior inside AAA-marked tests. */
-const enforceAaaPhasePurityRule = {
-    create(context) {
-        return {
-            CallExpression(node) {
-                const analysis = analyzeTestBlock(context, node);
-                if (analysis === void 0) {
-                    return;
-                }
-                reportPhasePurityViolations(context, analysis);
-            },
-        };
-    },
-    meta: {
-        docs: {
-            description: "Keep setup, action, and assertions inside their intended AAA phases.",
-            recommended: false,
-            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/enforce-aaa-phase-purity.md",
-        },
-        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,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

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

@@ -1,20 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,39 +0,0 @@
-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-vitest-incremental-casts/ast-helpers.d.ts

@@ -1,97 +0,0 @@
-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;
-/**
- * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
- * @param expression Expression to inspect.
- * @returns True when at least one cast in the chain uses unknown or any as the type annotation.
- * @example
- * ```typescript
- * const isEscapeHatch = hasEscapeHatchCast(expression);
- * ```
- */
-declare function hasEscapeHatchCast(expression: TSESTree.Expression): boolean;
-/**
- * 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;
-/**
- * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
- * 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, hasEscapeHatchCast, isSupportedProperty, isVitestMockCall, shouldWrapImplicitObject, unwrapExpression, };
-//# sourceMappingURL=ast-helpers.d.ts.map

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

@@ -1 +0,0 @@
-{"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,kBAAkB,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,GAAG,OAAO,CAoBpE;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;;;;;;;;;GASG;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,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,EACxB,gBAAgB,GACjB,CAAC"}

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

@@ -1,174 +0,0 @@
-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;
-}
-/**
- * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
- * @param expression Expression to inspect.
- * @returns True when at least one cast in the chain uses unknown or any as the type annotation.
- * @example
- * ```typescript
- * const isEscapeHatch = hasEscapeHatchCast(expression);
- * ```
- */
-function hasEscapeHatchCast(expression) {
-    let current = expression;
-    while (current.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||
-        current.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion ||
-        current.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression) {
-        if (current.typeAnnotation.type ===
-            TSESTree.AST_NODE_TYPES.TSUnknownKeyword ||
-            current.typeAnnotation.type === TSESTree.AST_NODE_TYPES.TSAnyKeyword) {
-            return true;
-        }
-        current = current.expression;
-    }
-    return false;
-}
-/**
- * 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]));
-}
-/**
- * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.
- * 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, hasEscapeHatchCast, 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 * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.\r\n * @param expression Expression to inspect.\r\n * @returns True when at least one cast in the chain uses unknown or any as the type annotation.\r\n * @example\r\n * ```typescript\r\n * const isEscapeHatch = hasEscapeHatchCast(expression);\r\n * ```\r\n */\r\nfunction hasEscapeHatchCast(expression: TSESTree.Expression): boolean {\r\n  let current: TSESTree.Expression = expression;\r\n\r\n  while (\r\n    current.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||\r\n    current.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion ||\r\n    current.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression\r\n  ) {\r\n    if (\r\n      current.typeAnnotation.type ===\r\n        TSESTree.AST_NODE_TYPES.TSUnknownKeyword ||\r\n      current.typeAnnotation.type === TSESTree.AST_NODE_TYPES.TSAnyKeyword\r\n    ) {\r\n      return true;\r\n    }\r\n\r\n    current = current.expression;\r\n  }\r\n\r\n  return false;\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 * Checks whether an expression's cast chain contains an escape-hatch cast through unknown or any.\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  hasEscapeHatchCast,\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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,QAAQ,CAAC"}