@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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

@@ -0,0 +1,28 @@
+import type { Rule } from "eslint";
+import type { RuleMatch } from "./types.js";
+/**
+ * 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[];
+/**
+ * Builds all autofix operations for every match in a file.
+ * @param matches Autofix contexts produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Combined fix list.
+ * @example
+ * ```typescript
+ * const fixes = buildFixes([], {} as never);
+ * void fixes;
+ * ```
+ */
+declare function buildFixes(matches: RuleMatch[], fixer: Rule.RuleFixer): Rule.Fix[];
+export { buildFix, buildFixes };
+//# sourceMappingURL=fix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAsCzC;;;;;;;;;;GAUG;AACH,iBAAS,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAKrE;AAED;;;;;;;;;;GAUG;AACH,iBAAS,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAK3E;AA+ID,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC"}

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

@@ -0,0 +1,171 @@
+import { buildImportFixes } from "./fix-import-statements.js";
+import { buildCombinedImportFixes } from "./fix-imports.js";
+/**
+ * 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 [
+        ...buildImportFixes(match, fixer),
+        ...buildNonImportFixes(match, fixer),
+    ];
+}
+/**
+ * Builds all autofix operations for every match in a file.
+ * @param matches Autofix contexts produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Combined fix list.
+ * @example
+ * ```typescript
+ * const fixes = buildFixes([], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildFixes(matches, fixer) {
+    return [
+        ...buildCombinedImportFixes(matches, fixer),
+        ...matches.flatMap((match) => buildNonImportFixes(match, fixer)),
+    ];
+}
+/**
+ * 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 all non-import autofix operations for a single match.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Combined non-import fix list.
+ * @example
+ * ```typescript
+ * const fixes = buildNonImportFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildNonImportFixes(match, fixer) {
+    return [
+        ...buildBindingFixes(match, fixer),
+        ...buildMemberRewriteFixes(match, fixer),
+        ...buildMockSpecifierFixes(match, fixer),
+        ...buildRemovalFixes(match, fixer),
+    ];
+}
+/**
+ * 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, buildFixes };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fix.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,SAAS,iBAAiB,CACxB,KAAgB,EAChB,KAAqB;IAErB,OAAO,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QACxC,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC9D,IAAI,WAAW,KAAK,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,eAAe,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK,CAC5C,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAC/B,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAChC,CAAC;QACF,OAAO;YACL,KAAK,CAAC,gBAAgB,CACpB,OAAO,CAAC,aAAa,EACrB,GAAG,OAAO,CAAC,YAAY,KAAK,eAAe,EAAE,CAC9C;SACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,QAAQ,CAAC,KAAgB,EAAE,KAAqB;IACvD,OAAO;QACL,GAAG,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC;QACjC,GAAG,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC;KACrC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,UAAU,CAAC,OAAoB,EAAE,KAAqB;IAC7D,OAAO;QACL,GAAG,wBAAwB,CAAC,OAAO,EAAE,KAAK,CAAC;QAC3C,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;KACjE,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,uBAAuB,CAC9B,KAAgB,EAChB,KAAqB;IAErB,OAAO,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAC1C,KAAK,CAAC,gBAAgB,CACpB,OAAO,CAAC,gBAAgB,EACxB,aAAa,OAAO,CAAC,YAAY,GAAG,CACrC,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,uBAAuB,CAC9B,KAAgB,EAChB,KAAqB;IAErB,IAAI,KAAK,CAAC,+BAA+B,EAAE,CAAC;QAC1C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACzD,OAAO;QACL,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,kBAAkB,EAAE,UAAU,UAAU,GAAG,CAAC;KAC1E,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,mBAAmB,CAC1B,KAAgB,EAChB,KAAqB;IAErB,OAAO;QACL,GAAG,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC;QAClC,GAAG,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC;QACxC,GAAG,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC;QACxC,GAAG,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC;KACnC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,iBAAiB,CACxB,KAAgB,EAChB,KAAqB;IAErB,MAAM,YAAY,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC,cAAc,EAAE,EAAE;QACzC,MAAM,aAAa,GAAG,sBAAsB,CAC1C,KAAK,CAAC,UAAU,EAChB,cAAc,CACf,CAAC;QACF,OAAO,KAAK,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,sBAAsB,CAC7B,UAAkB,EAClB,cAAqB;IAErB,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,cAAc,CAAC;IACpC,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACxD,OAAO,iBAAiB,KAAK,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC;QAC5B,CAAC,CAAC,CAAC,KAAK,EAAE,iBAAiB,GAAG,CAAC,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,wBAAwB,CAAC,KAAgB;IAChD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAiB,CAAC;IAC1C,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACrC,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC9D,IAAI,WAAW,KAAK,KAAK,CAAC,EAAE,CAAC;YAC3B,MAAM,GAAG,GAAG,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;YAChF,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,OAAO,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;AAChC,CAAC;AAED,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Range } from \"./match-helpers\";\nimport type { RuleMatch } from \"./types\";\n\nimport { buildImportFixes } from \"./fix-import-statements\";\nimport { buildCombinedImportFixes } from \"./fix-imports\";\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    ...buildImportFixes(match, fixer),\n    ...buildNonImportFixes(match, fixer),\n  ];\n}\n\n/**\n * Builds all autofix operations for every match in a file.\n * @param matches Autofix contexts produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns Combined fix list.\n * @example\n * ```typescript\n * const fixes = buildFixes([], {} as never);\n * void fixes;\n * ```\n */\nfunction buildFixes(matches: RuleMatch[], fixer: Rule.RuleFixer): Rule.Fix[] {\n  return [\n    ...buildCombinedImportFixes(matches, fixer),\n    ...matches.flatMap((match) => buildNonImportFixes(match, fixer)),\n  ];\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 all non-import autofix operations for a single match.\n * @param match Autofix context produced by the matcher.\n * @param fixer ESLint fixer.\n * @returns Combined non-import fix list.\n * @example\n * ```typescript\n * const fixes = buildNonImportFixes({} as never, {} as never);\n * void fixes;\n * ```\n */\nfunction buildNonImportFixes(\n  match: RuleMatch,\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  return [\n    ...buildBindingFixes(match, fixer),\n    ...buildMemberRewriteFixes(match, fixer),\n    ...buildMockSpecifierFixes(match, fixer),\n    ...buildRemovalFixes(match, fixer),\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, buildFixes };\n"]}

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 import type * as ESTree from "estree";
-import type { Binding, Declaration } from "./types";
+import type { Binding, Declaration } from "./types.js";
 /**
  * Collects bindings from a mock factory object.
  * @param objectExpression Returned object expression.

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-bindings.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAIpD;;;;;;;;;;GAUG;AACH,iBAAS,eAAe,CACtB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EACzC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GACrC,OAAO,EAAE,CAIX;AA8CD,OAAO,EAAE,eAAe,EAAE,CAAC"}

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

@@ -0,0 +1,52 @@
+import { hasRange } from "./match-helpers.js";
+/**
+ * Collects bindings from a mock factory object.
+ * @param objectExpression Returned object expression.
+ * @param declarations Known declarations by local name.
+ * @returns Collected bindings.
+ * @example
+ * ```typescript
+ * const bindings = collectBindings({ properties: [], type: "ObjectExpression" } as never, new Map());
+ * void bindings;
+ * ```
+ */
+function collectBindings(objectExpression, declarations) {
+    return objectExpression.properties
+        .map((propertyNode) => toBinding(propertyNode, declarations))
+        .filter((binding) => binding !== void 0);
+}
+/**
+ * Converts one object property into a binding when supported.
+ * @param propertyNode Object property candidate.
+ * @param declarations Known declarations.
+ * @returns Binding when property matches the rule shape.
+ * @example
+ * ```typescript
+ * const binding = toBinding({ type: "SpreadElement" } as never, new Map());
+ * void binding;
+ * ```
+ */
+function toBinding(propertyNode, declarations) {
+    if (propertyNode.type !== "Property" ||
+        propertyNode.key.type !== "Identifier") {
+        return void 0;
+    }
+    if (!hasRange(propertyNode) ||
+        !hasRange(propertyNode.key) ||
+        propertyNode.value.type !== "Identifier") {
+        return void 0;
+    }
+    if (!hasRange(propertyNode.value) ||
+        !declarations.has(propertyNode.value.name)) {
+        return void 0;
+    }
+    return {
+        exportedName: propertyNode.key.name,
+        localName: propertyNode.value.name,
+        propertyKeyRange: propertyNode.key.range,
+        propertyRange: propertyNode.range,
+        propertyValueRange: propertyNode.value.range,
+    };
+}
+export { collectBindings };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0Y2gtYmluZGluZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvcHJlZmVyLXZpLW1vY2tlZC1pbXBvcnQvbWF0Y2gtYmluZGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTNDOzs7Ozs7Ozs7O0dBVUc7QUFDSCxTQUFTLGVBQWUsQ0FDdEIsZ0JBQXlDLEVBQ3pDLFlBQXNDO0lBRXRDLE9BQU8sZ0JBQWdCLENBQUMsVUFBVTtTQUMvQixHQUFHLENBQUMsQ0FBQyxZQUFZLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxZQUFZLEVBQUUsWUFBWSxDQUFDLENBQUM7U0FDNUQsTUFBTSxDQUFDLENBQUMsT0FBTyxFQUFzQixFQUFFLENBQUMsT0FBTyxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUM7QUFDakUsQ0FBQztBQUVEOzs7Ozs7Ozs7O0dBVUc7QUFDSCxTQUFTLFNBQVMsQ0FDaEIsWUFBb0QsRUFDcEQsWUFBc0M7SUFFdEMsSUFDRSxZQUFZLENBQUMsSUFBSSxLQUFLLFVBQVU7UUFDaEMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEtBQUssWUFBWSxFQUN0QyxDQUFDO1FBQ0QsT0FBTyxLQUFLLENBQUMsQ0FBQztJQUNoQixDQUFDO0lBQ0QsSUFDRSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUM7UUFDdkIsQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQztRQUMzQixZQUFZLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxZQUFZLEVBQ3hDLENBQUM7UUFDRCxPQUFPLEtBQUssQ0FBQyxDQUFDO0lBQ2hCLENBQUM7SUFDRCxJQUNFLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUM7UUFDN0IsQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQzFDLENBQUM7UUFDRCxPQUFPLEtBQUssQ0FBQyxDQUFDO0lBQ2hCLENBQUM7SUFFRCxPQUFPO1FBQ0wsWUFBWSxFQUFFLFlBQVksQ0FBQyxHQUFHLENBQUMsSUFBSTtRQUNuQyxTQUFTLEVBQUUsWUFBWSxDQUFDLEtBQUssQ0FBQyxJQUFJO1FBQ2xDLGdCQUFnQixFQUFFLFlBQVksQ0FBQyxHQUFHLENBQUMsS0FBSztRQUN4QyxhQUFhLEVBQUUsWUFBWSxDQUFDLEtBQUs7UUFDakMsa0JBQWtCLEVBQUUsWUFBWSxDQUFDLEtBQUssQ0FBQyxLQUFLO0tBQzdDLENBQUM7QUFDSixDQUFDO0FBRUQsT0FBTyxFQUFFLGVBQWUsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgKiBhcyBFU1RyZWUgZnJvbSBcImVzdHJlZVwiO1xuXG5pbXBvcnQgdHlwZSB7IEJpbmRpbmcsIERlY2xhcmF0aW9uIH0gZnJvbSBcIi4vdHlwZXNcIjtcblxuaW1wb3J0IHsgaGFzUmFuZ2UgfSBmcm9tIFwiLi9tYXRjaC1oZWxwZXJzXCI7XG5cbi8qKlxuICogQ29sbGVjdHMgYmluZGluZ3MgZnJvbSBhIG1vY2sgZmFjdG9yeSBvYmplY3QuXG4gKiBAcGFyYW0gb2JqZWN0RXhwcmVzc2lvbiBSZXR1cm5lZCBvYmplY3QgZXhwcmVzc2lvbi5cbiAqIEBwYXJhbSBkZWNsYXJhdGlvbnMgS25vd24gZGVjbGFyYXRpb25zIGJ5IGxvY2FsIG5hbWUuXG4gKiBAcmV0dXJucyBDb2xsZWN0ZWQgYmluZGluZ3MuXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogY29uc3QgYmluZGluZ3MgPSBjb2xsZWN0QmluZGluZ3MoeyBwcm9wZXJ0aWVzOiBbXSwgdHlwZTogXCJPYmplY3RFeHByZXNzaW9uXCIgfSBhcyBuZXZlciwgbmV3IE1hcCgpKTtcbiAqIHZvaWQgYmluZGluZ3M7XG4gKiBgYGBcbiAqL1xuZnVuY3Rpb24gY29sbGVjdEJpbmRpbmdzKFxuICBvYmplY3RFeHByZXNzaW9uOiBFU1RyZWUuT2JqZWN0RXhwcmVzc2lvbixcbiAgZGVjbGFyYXRpb25zOiBNYXA8c3RyaW5nLCBEZWNsYXJhdGlvbj4sXG4pOiBCaW5kaW5nW10ge1xuICByZXR1cm4gb2JqZWN0RXhwcmVzc2lvbi5wcm9wZXJ0aWVzXG4gICAgLm1hcCgocHJvcGVydHlOb2RlKSA9PiB0b0JpbmRpbmcocHJvcGVydHlOb2RlLCBkZWNsYXJhdGlvbnMpKVxuICAgIC5maWx0ZXIoKGJpbmRpbmcpOiBiaW5kaW5nIGlzIEJpbmRpbmcgPT4gYmluZGluZyAhPT0gdm9pZCAwKTtcbn1cblxuLyoqXG4gKiBDb252ZXJ0cyBvbmUgb2JqZWN0IHByb3BlcnR5IGludG8gYSBiaW5kaW5nIHdoZW4gc3VwcG9ydGVkLlxuICogQHBhcmFtIHByb3BlcnR5Tm9kZSBPYmplY3QgcHJvcGVydHkgY2FuZGlkYXRlLlxuICogQHBhcmFtIGRlY2xhcmF0aW9ucyBLbm93biBkZWNsYXJhdGlvbnMuXG4gKiBAcmV0dXJucyBCaW5kaW5nIHdoZW4gcHJvcGVydHkgbWF0Y2hlcyB0aGUgcnVsZSBzaGFwZS5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBiaW5kaW5nID0gdG9CaW5kaW5nKHsgdHlwZTogXCJTcHJlYWRFbGVtZW50XCIgfSBhcyBuZXZlciwgbmV3IE1hcCgpKTtcbiAqIHZvaWQgYmluZGluZztcbiAqIGBgYFxuICovXG5mdW5jdGlvbiB0b0JpbmRpbmcoXG4gIHByb3BlcnR5Tm9kZTogRVNUcmVlLlByb3BlcnR5IHwgRVNUcmVlLlNwcmVhZEVsZW1lbnQsXG4gIGRlY2xhcmF0aW9uczogTWFwPHN0cmluZywgRGVjbGFyYXRpb24+LFxuKTogQmluZGluZyB8IHVuZGVmaW5lZCB7XG4gIGlmIChcbiAgICBwcm9wZXJ0eU5vZGUudHlwZSAhPT0gXCJQcm9wZXJ0eVwiIHx8XG4gICAgcHJvcGVydHlOb2RlLmtleS50eXBlICE9PSBcIklkZW50aWZpZXJcIlxuICApIHtcbiAgICByZXR1cm4gdm9pZCAwO1xuICB9XG4gIGlmIChcbiAgICAhaGFzUmFuZ2UocHJvcGVydHlOb2RlKSB8fFxuICAgICFoYXNSYW5nZShwcm9wZXJ0eU5vZGUua2V5KSB8fFxuICAgIHByb3BlcnR5Tm9kZS52YWx1ZS50eXBlICE9PSBcIklkZW50aWZpZXJcIlxuICApIHtcbiAgICByZXR1cm4gdm9pZCAwO1xuICB9XG4gIGlmIChcbiAgICAhaGFzUmFuZ2UocHJvcGVydHlOb2RlLnZhbHVlKSB8fFxuICAgICFkZWNsYXJhdGlvbnMuaGFzKHByb3BlcnR5Tm9kZS52YWx1ZS5uYW1lKVxuICApIHtcbiAgICByZXR1cm4gdm9pZCAwO1xuICB9XG5cbiAgcmV0dXJuIHtcbiAgICBleHBvcnRlZE5hbWU6IHByb3BlcnR5Tm9kZS5rZXkubmFtZSxcbiAgICBsb2NhbE5hbWU6IHByb3BlcnR5Tm9kZS52YWx1ZS5uYW1lLFxuICAgIHByb3BlcnR5S2V5UmFuZ2U6IHByb3BlcnR5Tm9kZS5rZXkucmFuZ2UsXG4gICAgcHJvcGVydHlSYW5nZTogcHJvcGVydHlOb2RlLnJhbmdlLFxuICAgIHByb3BlcnR5VmFsdWVSYW5nZTogcHJvcGVydHlOb2RlLnZhbHVlLnJhbmdlLFxuICB9O1xufVxuXG5leHBvcnQgeyBjb2xsZWN0QmluZGluZ3MgfTtcbiJdfQ==

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

@@ -1,9 +1,10 @@
 import type { Rule } from "eslint";
 import type * as ESTree from "estree";
-import type { Declaration } from "./types";
+import type { Declaration } from "./types.js";
 /**
  * Collects top-level `const x = vi.fn(...)` declarations.
  * @param program Program node.
+ * @param sourceCode Source code wrapper used to inspect attached comments.
  * @returns Declarations by local name.
  * @example
  * ```typescript

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-declarations.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-declarations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C;;;;;;;;;;GAUG;AACH,iBAAS,mBAAmB,CAC1B,OAAO,EAAE,MAAM,CAAC,OAAO,EACvB,UAAU,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,GAC1C,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAU1B;AA4JD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

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

@@ -0,0 +1,131 @@
+import { hasRange, isViFunctionCall } from "./match-helpers.js";
+/**
+ * Collects top-level `const x = vi.fn(...)` declarations.
+ * @param program Program node.
+ * @param sourceCode Source code wrapper used to inspect attached comments.
+ * @returns Declarations by local name.
+ * @example
+ * ```typescript
+ * const declarations = collectDeclarations({ body: [], sourceType: "module", type: "Program" } as never);
+ * void declarations;
+ * ```
+ */
+function collectDeclarations(program, sourceCode) {
+    const declarations = program.body
+        .map((statement) => toDeclaration(statement, sourceCode))
+        .filter((declaration) => declaration !== void 0);
+    return new Map(declarations.map((declaration) => [declaration.localName, declaration]));
+}
+/**
+ * Finds the earliest attached leading comment range for a declaration.
+ * @param commentsBefore Comments that appear before the declaration.
+ * @param sourceCode Source code wrapper used to inspect interstitial text.
+ * @param statementStart Original declaration start offset.
+ * @returns Earliest attached comment start, or the statement start.
+ * @example
+ * ```typescript
+ * const start = getAttachedCommentStart([], void 0, 10);
+ * void start;
+ * ```
+ */
+function getAttachedCommentStart(commentsBefore, sourceCode, statementStart) {
+    let removalStart = statementStart;
+    let nextStart = statementStart;
+    for (const comment of commentsBefore.toReversed()) {
+        const commentStart = getNextAttachedCommentStart(comment, sourceCode, nextStart);
+        if (commentStart === void 0) {
+            break;
+        }
+        removalStart = commentStart;
+        nextStart = commentStart;
+    }
+    return removalStart;
+}
+/**
+ * Returns the next attached comment start when a comment remains linked to the declaration.
+ * @param comment Candidate leading comment.
+ * @param sourceCode Source code wrapper used to inspect interstitial text.
+ * @param nextStart Current boundary that the comment must attach to.
+ * @returns Comment start when attached, otherwise `undefined`.
+ * @example
+ * ```typescript
+ * const start = getNextAttachedCommentStart({ type: "Block", value: "x" } as never, void 0, 5);
+ * void start;
+ * ```
+ */
+function getNextAttachedCommentStart(comment, sourceCode, nextStart) {
+    const commentRange = comment.range;
+    if (commentRange === void 0) {
+        return void 0;
+    }
+    const [commentStart, commentEnd] = commentRange;
+    const gapText = sourceCode?.text.slice(commentEnd, nextStart) ?? "";
+    return isAttachedLeadingGap(gapText) ? commentStart : void 0;
+}
+/**
+ * Returns the declaration removal range, including directly attached comments.
+ * @param statement Variable declaration statement.
+ * @param sourceCode Source code wrapper when available.
+ * @returns Statement range expanded to attached leading comments.
+ * @example
+ * ```typescript
+ * const range = getRemovalRange({ range: [5, 10], type: "VariableDeclaration" } as never);
+ * void range;
+ * ```
+ */
+function getRemovalRange(statement, sourceCode) {
+    const [statementStart, statementEnd] = statement.range;
+    const commentsBefore = sourceCode?.getCommentsBefore(statement) ?? [];
+    const removalStart = getAttachedCommentStart(commentsBefore, sourceCode, statementStart);
+    return [removalStart, statementEnd];
+}
+/**
+ * Returns true when whitespace between a comment and declaration keeps them attached.
+ * @param gapText Source text between adjacent nodes.
+ * @returns True when the gap contains no blank line.
+ * @example
+ * ```typescript
+ * const ok = isAttachedLeadingGap("\n");
+ * void ok;
+ * ```
+ */
+function isAttachedLeadingGap(gapText) {
+    return (/^[\t \r\n]*$/u.test(gapText) && !/(?:\r?\n)[\t ]*(?:\r?\n)/u.test(gapText));
+}
+/**
+ * Converts one top-level statement into a declaration when supported.
+ * @param statement Candidate statement.
+ * @param sourceCode Source code wrapper used to inspect attached comments.
+ * @returns Declaration when statement matches the rule shape.
+ * @example
+ * ```typescript
+ * const declaration = toDeclaration({ type: "EmptyStatement" } as never);
+ * void declaration;
+ * ```
+ */
+function toDeclaration(statement, sourceCode) {
+    if (statement.type !== "VariableDeclaration" || statement.kind !== "const") {
+        return void 0;
+    }
+    if (!hasRange(statement) || statement.declarations.length !== 1) {
+        return void 0;
+    }
+    const [declarator] = statement.declarations;
+    if (declarator === void 0 ||
+        declarator.id.type !== "Identifier" ||
+        !hasRange(declarator.id) ||
+        declarator.init === null ||
+        declarator.init === void 0 ||
+        !hasRange(declarator.init) ||
+        !isViFunctionCall(declarator.init)) {
+        return void 0;
+    }
+    return {
+        declarationIdRange: declarator.id.range,
+        initializerRange: declarator.init.range,
+        localName: declarator.id.name,
+        statementRange: getRemovalRange(statement, sourceCode),
+    };
+}
+export { collectDeclarations };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match-declarations.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-declarations.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport type { Declaration } from \"./types\";\n\nimport { hasRange, isViFunctionCall } from \"./match-helpers\";\n\n/**\n * Collects top-level `const x = vi.fn(...)` declarations.\n * @param program Program node.\n * @param sourceCode Source code wrapper used to inspect attached comments.\n * @returns Declarations by local name.\n * @example\n * ```typescript\n * const declarations = collectDeclarations({ body: [], sourceType: \"module\", type: \"Program\" } as never);\n * void declarations;\n * ```\n */\nfunction collectDeclarations(\n  program: ESTree.Program,\n  sourceCode?: Rule.RuleContext[\"sourceCode\"],\n): Map<string, Declaration> {\n  const declarations = program.body\n    .map((statement) => toDeclaration(statement, sourceCode))\n    .filter(\n      (declaration): declaration is Declaration => declaration !== void 0,\n    );\n\n  return new Map(\n    declarations.map((declaration) => [declaration.localName, declaration]),\n  );\n}\n\n/**\n * Finds the earliest attached leading comment range for a declaration.\n * @param commentsBefore Comments that appear before the declaration.\n * @param sourceCode Source code wrapper used to inspect interstitial text.\n * @param statementStart Original declaration start offset.\n * @returns Earliest attached comment start, or the statement start.\n * @example\n * ```typescript\n * const start = getAttachedCommentStart([], void 0, 10);\n * void start;\n * ```\n */\nfunction getAttachedCommentStart(\n  commentsBefore: readonly ESTree.Comment[],\n  sourceCode: Rule.RuleContext[\"sourceCode\"] | undefined,\n  statementStart: number,\n): number {\n  let removalStart = statementStart;\n  let nextStart = statementStart;\n\n  for (const comment of commentsBefore.toReversed()) {\n    const commentStart = getNextAttachedCommentStart(\n      comment,\n      sourceCode,\n      nextStart,\n    );\n    if (commentStart === void 0) {\n      break;\n    }\n\n    removalStart = commentStart;\n    nextStart = commentStart;\n  }\n\n  return removalStart;\n}\n\n/**\n * Returns the next attached comment start when a comment remains linked to the declaration.\n * @param comment Candidate leading comment.\n * @param sourceCode Source code wrapper used to inspect interstitial text.\n * @param nextStart Current boundary that the comment must attach to.\n * @returns Comment start when attached, otherwise `undefined`.\n * @example\n * ```typescript\n * const start = getNextAttachedCommentStart({ type: \"Block\", value: \"x\" } as never, void 0, 5);\n * void start;\n * ```\n */\nfunction getNextAttachedCommentStart(\n  comment: ESTree.Comment,\n  sourceCode: Rule.RuleContext[\"sourceCode\"] | undefined,\n  nextStart: number,\n): number | undefined {\n  const commentRange = comment.range;\n\n  if (commentRange === void 0) {\n    return void 0;\n  }\n\n  const [commentStart, commentEnd] = commentRange;\n  const gapText = sourceCode?.text.slice(commentEnd, nextStart) ?? \"\";\n\n  return isAttachedLeadingGap(gapText) ? commentStart : void 0;\n}\n\n/**\n * Returns the declaration removal range, including directly attached comments.\n * @param statement Variable declaration statement.\n * @param sourceCode Source code wrapper when available.\n * @returns Statement range expanded to attached leading comments.\n * @example\n * ```typescript\n * const range = getRemovalRange({ range: [5, 10], type: \"VariableDeclaration\" } as never);\n * void range;\n * ```\n */\nfunction getRemovalRange(\n  statement: ESTree.VariableDeclaration & {\n    /** Source range for the full declaration statement. */\n    range: [number, number];\n  },\n  sourceCode?: Rule.RuleContext[\"sourceCode\"],\n): [number, number] {\n  const [statementStart, statementEnd] = statement.range;\n  const commentsBefore = sourceCode?.getCommentsBefore(statement) ?? [];\n  const removalStart = getAttachedCommentStart(\n    commentsBefore,\n    sourceCode,\n    statementStart,\n  );\n\n  return [removalStart, statementEnd];\n}\n\n/**\n * Returns true when whitespace between a comment and declaration keeps them attached.\n * @param gapText Source text between adjacent nodes.\n * @returns True when the gap contains no blank line.\n * @example\n * ```typescript\n * const ok = isAttachedLeadingGap(\"\\n\");\n * void ok;\n * ```\n */\nfunction isAttachedLeadingGap(gapText: string): boolean {\n  return (\n    /^[\\t \\r\\n]*$/u.test(gapText) && !/(?:\\r?\\n)[\\t ]*(?:\\r?\\n)/u.test(gapText)\n  );\n}\n\n/**\n * Converts one top-level statement into a declaration when supported.\n * @param statement Candidate statement.\n * @param sourceCode Source code wrapper used to inspect attached comments.\n * @returns Declaration when statement matches the rule shape.\n * @example\n * ```typescript\n * const declaration = toDeclaration({ type: \"EmptyStatement\" } as never);\n * void declaration;\n * ```\n */\nfunction toDeclaration(\n  statement: ESTree.Program[\"body\"][number],\n  sourceCode?: Rule.RuleContext[\"sourceCode\"],\n): Declaration | undefined {\n  if (statement.type !== \"VariableDeclaration\" || statement.kind !== \"const\") {\n    return void 0;\n  }\n  if (!hasRange(statement) || statement.declarations.length !== 1) {\n    return void 0;\n  }\n\n  const [declarator] = statement.declarations;\n  if (\n    declarator === void 0 ||\n    declarator.id.type !== \"Identifier\" ||\n    !hasRange(declarator.id) ||\n    declarator.init === null ||\n    declarator.init === void 0 ||\n    !hasRange(declarator.init) ||\n    !isViFunctionCall(declarator.init)\n  ) {\n    return void 0;\n  }\n\n  return {\n    declarationIdRange: declarator.id.range,\n    initializerRange: declarator.init.range,\n    localName: declarator.id.name,\n    statementRange: getRemovalRange(statement, sourceCode),\n  };\n}\n\nexport { collectDeclarations };\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAQtC,qCAAqC;AACrC,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9B,qCAAqC;AACrC,KAAK,SAAS,GAAG,MAAM,CAAC,IAAI,GAAG;IAC7B,uCAAuC;IACvC,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;;;;;;GASG;AACH,iBAAS,sBAAsB,CAC7B,iBAAiB,EAAE,MAAM,CAAC,UAAU,GACnC,MAAM,CAAC,gBAAgB,GAAG,SAAS,CAmBrC;AAED;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,cAAc,EAAE,MAAM,CAAC,UAAU,GAChC,MAAM,GAAG,SAAS,CAYpB;AAED;;;;;;;;;GASG;AACH,iBAAS,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,SAAS,CAQtD;AAED;;;;;;;;;GASG;AACH,iBAAS,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,UAAU,GAAG,IAAI,GAAG,OAAO,CAevE;AAED,YAAY,EAAE,KAAK,EAAE,CAAC;AACtB,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,UAAU,EACV,QAAQ,EACR,gBAAgB,GACjB,CAAC"}

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

@@ -0,0 +1,102 @@
+/**
+ * Resolves the object literal returned from a mock factory.
+ * @param factoryExpression Factory expression from `vi.mock` or `vi.doMock`.
+ * @returns Returned object expression when present.
+ * @example
+ * ```typescript
+ * const result = getFactoryReturnObject({ type: "Identifier" } as never);
+ * void result;
+ * ```
+ */
+function getFactoryReturnObject(factoryExpression) {
+    if (factoryExpression.type !== "ArrowFunctionExpression") {
+        return void 0;
+    }
+    const { body } = factoryExpression;
+    if (body.type === "ObjectExpression") {
+        return body;
+    }
+    if (body.type !== "BlockStatement") {
+        return void 0;
+    }
+    const returnStatement = body.body.find((statement) => statement.type === "ReturnStatement");
+    const returnArgument = returnStatement?.argument;
+    return returnArgument?.type === "ObjectExpression" ? returnArgument : void 0;
+}
+/**
+ * Extracts a module specifier string from a mock call argument.
+ * @param moduleArgument First argument of `vi.mock` or `vi.doMock`.
+ * @returns String module specifier when available.
+ * @example
+ * ```typescript
+ * const specifier = getModuleSpecifier({ type: "Literal", value: "./x" } as never);
+ * void specifier;
+ * ```
+ */
+function getModuleSpecifier(moduleArgument) {
+    if (moduleArgument.type === "ImportExpression") {
+        const { source } = moduleArgument;
+        return source.type === "Literal" && typeof source.value === "string"
+            ? source.value
+            : void 0;
+    }
+    return moduleArgument.type === "Literal" &&
+        typeof moduleArgument.value === "string"
+        ? moduleArgument.value
+        : void 0;
+}
+/**
+ * Determines the newline sequence used in source text.
+ * @param sourceText Full source text.
+ * @returns Detected newline sequence.
+ * @example
+ * ```typescript
+ * const newline = getNewline("a\r\nb");
+ * void newline;
+ * ```
+ */
+function getNewline(sourceText) {
+    return sourceText.includes("\r\n") ? "\r\n" : "\n";
+}
+/**
+ * Checks whether a node includes a numeric `range` tuple.
+ * @param node Node to inspect.
+ * @returns True when the node has a valid `range`.
+ * @example
+ * ```typescript
+ * const ok = hasRange({ range: [0, 1] } as never);
+ * void ok;
+ * ```
+ */
+function hasRange(node) {
+    const rangeValue = node.range;
+    return (Array.isArray(rangeValue) &&
+        rangeValue.length === 2 &&
+        typeof rangeValue[0] === "number" &&
+        typeof rangeValue[1] === "number");
+}
+/**
+ * Returns true when an expression is a `vi.fn(...)` call.
+ * @param expression Expression to inspect.
+ * @returns True when the expression is a `vi.fn` call.
+ * @example
+ * ```typescript
+ * const ok = isViFunctionCall(null);
+ * void ok;
+ * ```
+ */
+function isViFunctionCall(expression) {
+    if (expression?.type !== "CallExpression") {
+        return false;
+    }
+    if (expression.callee.type !== "MemberExpression") {
+        return false;
+    }
+    const { object, property } = expression.callee;
+    return (object.type === "Identifier" &&
+        object.name === "vi" &&
+        property.type === "Identifier" &&
+        property.name === "fn");
+}
+export { getFactoryReturnObject, getModuleSpecifier, getNewline, hasRange, isViFunctionCall, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-helpers.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;GASG;AACH,SAAS,sBAAsB,CAC7B,iBAAoC;IAEpC,IAAI,iBAAiB,CAAC,IAAI,KAAK,yBAAyB,EAAE,CAAC;QACzD,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,EAAE,IAAI,EAAE,GAAG,iBAAiB,CAAC;IACnC,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CACpC,CAAC,SAAS,EAAuC,EAAE,CACjD,SAAS,CAAC,IAAI,KAAK,iBAAiB,CACvC,CAAC;IACF,MAAM,cAAc,GAAG,eAAe,EAAE,QAAQ,CAAC;IACjD,OAAO,cAAc,EAAE,IAAI,KAAK,kBAAkB,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,kBAAkB,CACzB,cAAiC;IAEjC,IAAI,cAAc,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QAC/C,MAAM,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC;QAClC,OAAO,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ;YAClE,CAAC,CAAC,MAAM,CAAC,KAAK;YACd,CAAC,CAAC,KAAK,CAAC,CAAC;IACb,CAAC;IAED,OAAO,cAAc,CAAC,IAAI,KAAK,SAAS;QACtC,OAAO,cAAc,CAAC,KAAK,KAAK,QAAQ;QACxC,CAAC,CAAC,cAAc,CAAC,KAAK;QACtB,CAAC,CAAC,KAAK,CAAC,CAAC;AACb,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,UAAU,CAAC,UAAkB;IACpC,OAAO,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AACrD,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,QAAQ,CAAC,IAAiB;IACjC,MAAM,UAAU,GAAI,IAAsC,CAAC,KAAK,CAAC;IACjE,OAAO,CACL,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC;QACzB,UAAU,CAAC,MAAM,KAAK,CAAC;QACvB,OAAO,UAAU,CAAC,CAAC,CAAC,KAAK,QAAQ;QACjC,OAAO,UAAU,CAAC,CAAC,CAAC,KAAK,QAAQ,CAClC,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,gBAAgB,CAAC,UAAoC;IAC5D,IAAI,UAAU,EAAE,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QAClD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC;IAC/C,OAAO,CACL,MAAM,CAAC,IAAI,KAAK,YAAY;QAC5B,MAAM,CAAC,IAAI,KAAK,IAAI;QACpB,QAAQ,CAAC,IAAI,KAAK,YAAY;QAC9B,QAAQ,CAAC,IAAI,KAAK,IAAI,CACvB,CAAC;AACJ,CAAC;AAGD,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,UAAU,EACV,QAAQ,EACR,gBAAgB,GACjB,CAAC","sourcesContent":["import type * as ESTree from \"estree\";\n\n/** Type definition for rule data. */\ninterface OptionalRangeField {\n  /** Potential range payload from unknown node-like values. */\n  range?: unknown;\n}\n\n/** Type definition for rule data. */\ntype Range = [number, number];\n\n/** Type definition for rule data. */\ntype RangeNode = ESTree.Node & {\n  /** Source range tuple for the node. */\n  range: Range;\n};\n\n/**\n * Resolves the object literal returned from a mock factory.\n * @param factoryExpression Factory expression from `vi.mock` or `vi.doMock`.\n * @returns Returned object expression when present.\n * @example\n * ```typescript\n * const result = getFactoryReturnObject({ type: \"Identifier\" } as never);\n * void result;\n * ```\n */\nfunction getFactoryReturnObject(\n  factoryExpression: ESTree.Expression,\n): ESTree.ObjectExpression | undefined {\n  if (factoryExpression.type !== \"ArrowFunctionExpression\") {\n    return void 0;\n  }\n\n  const { body } = factoryExpression;\n  if (body.type === \"ObjectExpression\") {\n    return body;\n  }\n  if (body.type !== \"BlockStatement\") {\n    return void 0;\n  }\n\n  const returnStatement = body.body.find(\n    (statement): statement is ESTree.ReturnStatement =>\n      statement.type === \"ReturnStatement\",\n  );\n  const returnArgument = returnStatement?.argument;\n  return returnArgument?.type === \"ObjectExpression\" ? returnArgument : void 0;\n}\n\n/**\n * Extracts a module specifier string from a mock call argument.\n * @param moduleArgument First argument of `vi.mock` or `vi.doMock`.\n * @returns String module specifier when available.\n * @example\n * ```typescript\n * const specifier = getModuleSpecifier({ type: \"Literal\", value: \"./x\" } as never);\n * void specifier;\n * ```\n */\nfunction getModuleSpecifier(\n  moduleArgument: ESTree.Expression,\n): string | undefined {\n  if (moduleArgument.type === \"ImportExpression\") {\n    const { source } = moduleArgument;\n    return source.type === \"Literal\" && typeof source.value === \"string\"\n      ? source.value\n      : void 0;\n  }\n\n  return moduleArgument.type === \"Literal\" &&\n    typeof moduleArgument.value === \"string\"\n    ? moduleArgument.value\n    : void 0;\n}\n\n/**\n * Determines the newline sequence used in source text.\n * @param sourceText Full source text.\n * @returns Detected newline sequence.\n * @example\n * ```typescript\n * const newline = getNewline(\"a\\r\\nb\");\n * void newline;\n * ```\n */\nfunction getNewline(sourceText: string): \"\\n\" | \"\\r\\n\" {\n  return sourceText.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n}\n\n/**\n * Checks whether a node includes a numeric `range` tuple.\n * @param node Node to inspect.\n * @returns True when the node has a valid `range`.\n * @example\n * ```typescript\n * const ok = hasRange({ range: [0, 1] } as never);\n * void ok;\n * ```\n */\nfunction hasRange(node: ESTree.Node): node is RangeNode {\n  const rangeValue = (node as unknown as OptionalRangeField).range;\n  return (\n    Array.isArray(rangeValue) &&\n    rangeValue.length === 2 &&\n    typeof rangeValue[0] === \"number\" &&\n    typeof rangeValue[1] === \"number\"\n  );\n}\n\n/**\n * Returns true when an expression is a `vi.fn(...)` call.\n * @param expression Expression to inspect.\n * @returns True when the expression is a `vi.fn` call.\n * @example\n * ```typescript\n * const ok = isViFunctionCall(null);\n * void ok;\n * ```\n */\nfunction isViFunctionCall(expression: ESTree.Expression | null): boolean {\n  if (expression?.type !== \"CallExpression\") {\n    return false;\n  }\n  if (expression.callee.type !== \"MemberExpression\") {\n    return false;\n  }\n\n  const { object, property } = expression.callee;\n  return (\n    object.type === \"Identifier\" &&\n    object.name === \"vi\" &&\n    property.type === \"Identifier\" &&\n    property.name === \"fn\"\n  );\n}\n\nexport type { Range };\nexport {\n  getFactoryReturnObject,\n  getModuleSpecifier,\n  getNewline,\n  hasRange,\n  isViFunctionCall,\n};\n"]}

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

@@ -1,5 +1,5 @@
 import type * as ESTree from "estree";
-import type { ImportPlan } from "./types";
+import type { ImportPlan } from "./types.js";
 /**
  * Resolves whether imports should be updated in place or inserted.
  * @param program Program node to inspect.

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-imports.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAGtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAwK1C;;;;;;;;;;;GAWG;AACH,iBAAS,iBAAiB,CACxB,OAAO,EAAE,MAAM,CAAC,OAAO,EACvB,eAAe,EAAE,MAAM,EACvB,KAAK,EAAE,MAAM,EAAE,GACd,UAAU,CASZ;AAqBD,OAAO,EAAE,iBAAiB,EAAE,CAAC"}