@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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

@@ -0,0 +1,85 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { aaaPhaseOrder, analyzeTestBlock, getFlattenedSections } from "../aaa/index.js";
+/**
+ * Reports a duplicate or out-of-order AAA section comment.
+ * @param input Composite reporting input for the current section.
+ * @example
+ * ```typescript
+ * reportSectionIssue({
+ *   context: {} as Rule.RuleContext,
+ *   messageId: "duplicateSection",
+ *   section: {} as ReturnType<typeof getFlattenedSections>[number],
+ * });
+ * ```
+ */
+const reportSectionIssue = (input) => {
+    const { context, messageId, section } = input;
+    context.report({
+        data: { section: section.phase },
+        messageId,
+        node: section.comment,
+    });
+};
+/**
+ * Tracks the current AAA ordering state for one flattened section.
+ * @param input Composite ordering state for the current section.
+ * @returns Updated phase order watermark.
+ * @example
+ * ```typescript
+ * const nextOrder = updateSectionOrder({
+ *   context: {} as Rule.RuleContext,
+ *   lastPhaseOrder: -1,
+ *   section: {} as ReturnType<typeof getFlattenedSections>[number],
+ *   seenPhases: new Set(),
+ * });
+ * void nextOrder;
+ * ```
+ */
+const updateSectionOrder = (input) => {
+    const { context, lastPhaseOrder, section, seenPhases } = input;
+    if (seenPhases.has(section.phase)) {
+        reportSectionIssue({ context, messageId: "duplicateSection", section });
+        return lastPhaseOrder;
+    }
+    const currentPhaseOrder = aaaPhaseOrder[section.phase];
+    if (currentPhaseOrder < lastPhaseOrder) {
+        reportSectionIssue({ context, messageId: "invalidOrder", section });
+    }
+    seenPhases.add(section.phase);
+    return Math.max(lastPhaseOrder, currentPhaseOrder);
+};
+/** Enforces a single Arrange/Act/Assert sequence inside supported test blocks. */
+const enforceAaaStructureRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                const flattenedSections = getFlattenedSections(analysis);
+                const seenPhases = new Set();
+                let lastPhaseOrder = -1;
+                for (const section of flattenedSections) {
+                    lastPhaseOrder = updateSectionOrder({
+                        context,
+                        lastPhaseOrder,
+                        section,
+                        seenPhases,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("enforce-aaa-structure", "Require AAA sections to appear once and in Arrange, Act, Assert order."),
+        messages: {
+            duplicateSection: "Use the // {{section}} section comment only once per test.",
+            invalidOrder: "Move the // {{section}} section comment so AAA phases stay in Arrange, Act, Assert order.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { enforceAaaStructureRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{testing → domain/testing}/index.d.ts

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

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

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

package/dist/domain/testing/index.js

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

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

@@ -0,0 +1,29 @@
+import type { Rule } from "eslint";
+import type { RuleMatch } from "./types.js";
+/**
+ * Builds fixes for adding or updating imports.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Import fixes for one match.
+ * @example
+ * ```typescript
+ * const fixes = buildImportFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+declare function buildImportFixes(match: RuleMatch, fixer: Rule.RuleFixer): Rule.Fix[];
+/**
+ * Creates an import statement string from import parts.
+ * @param moduleSpecifier Module path used in the generated statement.
+ * @param defaultImportName Existing default-import local identifier, when present.
+ * @param names Named imports to include in braces.
+ * @returns Fully formatted import statement text.
+ * @example
+ * ```typescript
+ * const text = buildImportStatement("./x", void 0, ["a"]);
+ * void text;
+ * ```
+ */
+declare function buildImportStatement(moduleSpecifier: string, defaultImportName: string | undefined, names: readonly string[]): string;
+export { buildImportFixes, buildImportStatement };
+//# sourceMappingURL=fix-import-statements.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix-import-statements.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-import-statements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,iBAAS,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAa7E;AAyCD;;;;;;;;;;;GAWG;AACH,iBAAS,oBAAoB,CAC3B,eAAe,EAAE,MAAM,EACvB,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,CAOR;AAsCD,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC"}

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

@@ -0,0 +1,90 @@
+/**
+ * Builds fixes for adding or updating imports.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Import fixes for one match.
+ * @example
+ * ```typescript
+ * const fixes = buildImportFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildImportFixes(match, fixer) {
+    const { names } = match.importPlan;
+    if (names.length === 0) {
+        return [];
+    }
+    const sortedNames = [...names].toSorted();
+    const updateFix = buildImportUpdateFix(match, sortedNames, fixer);
+    return updateFix === void 0
+        ? buildImportInsertFixes(match, sortedNames, fixer)
+        : [updateFix];
+}
+/**
+ * Builds import insertion fixes when no compatible import exists.
+ * @param match Autofix context produced by the matcher.
+ * @param sortedNames Sorted names that must be imported.
+ * @param fixer ESLint fixer.
+ * @returns Import insertion fixes for one match.
+ * @example
+ * ```typescript
+ * const fixes = buildImportInsertFixes({ importPlan: { moduleSpecifier: "./x", names: [] }, newline: "\n" } as never, [], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildImportInsertFixes(match, sortedNames, fixer) {
+    const statementText = buildImportStatement(match.importPlan.moduleSpecifier, void 0, sortedNames);
+    const { afterRange } = match.importPlan.insert ?? {};
+    return afterRange === void 0
+        ? [
+            fixer.insertTextBeforeRange([0, 0], `${statementText}${match.newline}${match.newline}`),
+        ]
+        : [
+            fixer.insertTextAfterRange(afterRange, `${match.newline}${statementText}`),
+        ];
+}
+/**
+ * Creates an import statement string from import parts.
+ * @param moduleSpecifier Module path used in the generated statement.
+ * @param defaultImportName Existing default-import local identifier, when present.
+ * @param names Named imports to include in braces.
+ * @returns Fully formatted import statement text.
+ * @example
+ * ```typescript
+ * const text = buildImportStatement("./x", void 0, ["a"]);
+ * void text;
+ * ```
+ */
+function buildImportStatement(moduleSpecifier, defaultImportName, names) {
+    const moduleText = JSON.stringify(moduleSpecifier);
+    const namedText = `{ ${names.join(", ")} }`;
+    return defaultImportName === void 0
+        ? `import ${namedText} from ${moduleText};`
+        : `import ${defaultImportName}, ${namedText} from ${moduleText};`;
+}
+/**
+ * Builds an import update fix when an existing import is compatible.
+ * @param match Autofix context produced by the matcher.
+ * @param sortedNames Sorted names that must be imported.
+ * @param fixer ESLint fixer.
+ * @returns Replacement fix when an import can be updated.
+ * @example
+ * ```typescript
+ * const fix = buildImportUpdateFix({ importPlan: { moduleSpecifier: "./x", names: [] } } as never, [], {} as never);
+ * void fix;
+ * ```
+ */
+function buildImportUpdateFix(match, sortedNames, fixer) {
+    const { moduleSpecifier, update } = match.importPlan;
+    if (update === void 0) {
+        return void 0;
+    }
+    const { defaultImportName, existingNamedImports, range } = update;
+    const mergedNames = [
+        ...new Set([...sortedNames, ...existingNamedImports]),
+    ].toSorted();
+    const statementText = buildImportStatement(moduleSpecifier, defaultImportName, mergedNames);
+    return fixer.replaceTextRange(range, statementText);
+}
+export { buildImportFixes, buildImportStatement };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fix-import-statements.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-import-statements.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,SAAS,gBAAgB,CAAC,KAAgB,EAAE,KAAqB;IAC/D,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC;IAEnC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,WAAW,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC1C,MAAM,SAAS,GAAG,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAElE,OAAO,SAAS,KAAK,KAAK,CAAC;QACzB,CAAC,CAAC,sBAAsB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC;QACnD,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,sBAAsB,CAC7B,KAAgB,EAChB,WAAqB,EACrB,KAAqB;IAErB,MAAM,aAAa,GAAG,oBAAoB,CACxC,KAAK,CAAC,UAAU,CAAC,eAAe,EAChC,KAAK,CAAC,EACN,WAAW,CACZ,CAAC;IACF,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,IAAI,EAAE,CAAC;IAErD,OAAO,UAAU,KAAK,KAAK,CAAC;QAC1B,CAAC,CAAC;YACE,KAAK,CAAC,qBAAqB,CACzB,CAAC,CAAC,EAAE,CAAC,CAAC,EACN,GAAG,aAAa,GAAG,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,CACnD;SACF;QACH,CAAC,CAAC;YACE,KAAK,CAAC,oBAAoB,CACxB,UAAU,EACV,GAAG,KAAK,CAAC,OAAO,GAAG,aAAa,EAAE,CACnC;SACF,CAAC;AACR,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,oBAAoB,CAC3B,eAAuB,EACvB,iBAAqC,EACrC,KAAwB;IAExB,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;IACnD,MAAM,SAAS,GAAG,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IAE5C,OAAO,iBAAiB,KAAK,KAAK,CAAC;QACjC,CAAC,CAAC,UAAU,SAAS,SAAS,UAAU,GAAG;QAC3C,CAAC,CAAC,UAAU,iBAAiB,KAAK,SAAS,SAAS,UAAU,GAAG,CAAC;AACtE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,oBAAoB,CAC3B,KAAgB,EAChB,WAAqB,EACrB,KAAqB;IAErB,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC;IAErD,IAAI,MAAM,KAAK,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;IAClE,MAAM,WAAW,GAAG;QAClB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,WAAW,EAAE,GAAG,oBAAoB,CAAC,CAAC;KACtD,CAAC,QAAQ,EAAE,CAAC;IACb,MAAM,aAAa,GAAG,oBAAoB,CACxC,eAAe,EACf,iBAAiB,EACjB,WAAW,CACZ,CAAC;IAEF,OAAO,KAAK,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;AACtD,CAAC;AAED,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { RuleMatch } from \"./types\";\r\n\r\n/**\r\n * Builds fixes for adding or updating imports.\r\n * @param match Autofix context produced by the matcher.\r\n * @param fixer ESLint fixer.\r\n * @returns Import fixes for one match.\r\n * @example\r\n * ```typescript\r\n * const fixes = buildImportFixes({} as never, {} as never);\r\n * void fixes;\r\n * ```\r\n */\r\nfunction buildImportFixes(match: RuleMatch, fixer: Rule.RuleFixer): Rule.Fix[] {\r\n  const { names } = match.importPlan;\r\n\r\n  if (names.length === 0) {\r\n    return [];\r\n  }\r\n\r\n  const sortedNames = [...names].toSorted();\r\n  const updateFix = buildImportUpdateFix(match, sortedNames, fixer);\r\n\r\n  return updateFix === void 0\r\n    ? buildImportInsertFixes(match, sortedNames, fixer)\r\n    : [updateFix];\r\n}\r\n\r\n/**\r\n * Builds import insertion fixes when no compatible import exists.\r\n * @param match Autofix context produced by the matcher.\r\n * @param sortedNames Sorted names that must be imported.\r\n * @param fixer ESLint fixer.\r\n * @returns Import insertion fixes for one match.\r\n * @example\r\n * ```typescript\r\n * const fixes = buildImportInsertFixes({ importPlan: { moduleSpecifier: \"./x\", names: [] }, newline: \"\\n\" } as never, [], {} as never);\r\n * void fixes;\r\n * ```\r\n */\r\nfunction buildImportInsertFixes(\r\n  match: RuleMatch,\r\n  sortedNames: string[],\r\n  fixer: Rule.RuleFixer,\r\n): Rule.Fix[] {\r\n  const statementText = buildImportStatement(\r\n    match.importPlan.moduleSpecifier,\r\n    void 0,\r\n    sortedNames,\r\n  );\r\n  const { afterRange } = match.importPlan.insert ?? {};\r\n\r\n  return afterRange === void 0\r\n    ? [\r\n        fixer.insertTextBeforeRange(\r\n          [0, 0],\r\n          `${statementText}${match.newline}${match.newline}`,\r\n        ),\r\n      ]\r\n    : [\r\n        fixer.insertTextAfterRange(\r\n          afterRange,\r\n          `${match.newline}${statementText}`,\r\n        ),\r\n      ];\r\n}\r\n\r\n/**\r\n * Creates an import statement string from import parts.\r\n * @param moduleSpecifier Module path used in the generated statement.\r\n * @param defaultImportName Existing default-import local identifier, when present.\r\n * @param names Named imports to include in braces.\r\n * @returns Fully formatted import statement text.\r\n * @example\r\n * ```typescript\r\n * const text = buildImportStatement(\"./x\", void 0, [\"a\"]);\r\n * void text;\r\n * ```\r\n */\r\nfunction buildImportStatement(\r\n  moduleSpecifier: string,\r\n  defaultImportName: string | undefined,\r\n  names: readonly string[],\r\n): string {\r\n  const moduleText = JSON.stringify(moduleSpecifier);\r\n  const namedText = `{ ${names.join(\", \")} }`;\r\n\r\n  return defaultImportName === void 0\r\n    ? `import ${namedText} from ${moduleText};`\r\n    : `import ${defaultImportName}, ${namedText} from ${moduleText};`;\r\n}\r\n\r\n/**\r\n * Builds an import update fix when an existing import is compatible.\r\n * @param match Autofix context produced by the matcher.\r\n * @param sortedNames Sorted names that must be imported.\r\n * @param fixer ESLint fixer.\r\n * @returns Replacement fix when an import can be updated.\r\n * @example\r\n * ```typescript\r\n * const fix = buildImportUpdateFix({ importPlan: { moduleSpecifier: \"./x\", names: [] } } as never, [], {} as never);\r\n * void fix;\r\n * ```\r\n */\r\nfunction buildImportUpdateFix(\r\n  match: RuleMatch,\r\n  sortedNames: string[],\r\n  fixer: Rule.RuleFixer,\r\n): Rule.Fix | undefined {\r\n  const { moduleSpecifier, update } = match.importPlan;\r\n\r\n  if (update === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  const { defaultImportName, existingNamedImports, range } = update;\r\n  const mergedNames = [\r\n    ...new Set([...sortedNames, ...existingNamedImports]),\r\n  ].toSorted();\r\n  const statementText = buildImportStatement(\r\n    moduleSpecifier,\r\n    defaultImportName,\r\n    mergedNames,\r\n  );\r\n\r\n  return fixer.replaceTextRange(range, statementText);\r\n}\r\n\r\nexport { buildImportFixes, buildImportStatement };\r\n"]}

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

@@ -0,0 +1,31 @@
+import type { Rule } from "eslint";
+/** Combined import work for one module across all matches. */
+interface CombinedImportPlanLike {
+    /** Module imported by this plan. */
+    moduleSpecifier: string;
+    /** Named imports required for this module. */
+    names: Set<string>;
+    /** Existing import replacement plan when present. */
+    update?: {
+        /** Existing default import local name. */
+        defaultImportName?: string;
+        /** Existing named imports already present. */
+        existingNamedImports: string[];
+        /** Import range to replace. */
+        range: [number, number];
+    };
+}
+/**
+ * Builds replacement fixes for existing compatible imports.
+ * @param combinedPlans Combined plans keyed by module specifier.
+ * @param fixer ESLint fixer.
+ * @returns Replacement fixes for existing imports.
+ * @example
+ * ```typescript
+ * const fixes = buildCombinedUpdateFixes(new Map(), {} as never);
+ * void fixes;
+ * ```
+ */
+declare function buildCombinedUpdateFixes(combinedPlans: Map<string, CombinedImportPlanLike>, fixer: Rule.RuleFixer): Rule.Fix[];
+export { buildCombinedUpdateFixes };
+//# sourceMappingURL=fix-import-updates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix-import-updates.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-import-updates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAInC,8DAA8D;AAC9D,UAAU,sBAAsB;IAC9B,oCAAoC;IACpC,eAAe,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnB,qDAAqD;IACrD,MAAM,CAAC,EAAE;QACP,0CAA0C;QAC1C,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,8CAA8C;QAC9C,oBAAoB,EAAE,MAAM,EAAE,CAAC;QAC/B,+BAA+B;QAC/B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACzB,CAAC;CACH;AAED;;;;;;;;;;GAUG;AACH,iBAAS,wBAAwB,CAC/B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,EAClD,KAAK,EAAE,IAAI,CAAC,SAAS,GACpB,IAAI,CAAC,GAAG,EAAE,CAMZ;AAoCD,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -0,0 +1,43 @@
+import { buildImportStatement } from "./fix-import-statements.js";
+/**
+ * Builds replacement fixes for existing compatible imports.
+ * @param combinedPlans Combined plans keyed by module specifier.
+ * @param fixer ESLint fixer.
+ * @returns Replacement fixes for existing imports.
+ * @example
+ * ```typescript
+ * const fixes = buildCombinedUpdateFixes(new Map(), {} as never);
+ * void fixes;
+ * ```
+ */
+function buildCombinedUpdateFixes(combinedPlans, fixer) {
+    return [...combinedPlans.values()].flatMap((plan) => {
+        const updateFix = toCombinedUpdateFix(plan, fixer);
+        return updateFix === void 0 ? [] : [updateFix];
+    });
+}
+/**
+ * Builds a replacement fix for one combined update plan.
+ * @param plan Combined import plan for one module.
+ * @param fixer ESLint fixer.
+ * @returns Replacement fix when the module already has a compatible import.
+ * @example
+ * ```typescript
+ * const fix = toCombinedUpdateFix({ moduleSpecifier: "./x", names: new Set() } as never, {} as never);
+ * void fix;
+ * ```
+ */
+function toCombinedUpdateFix(plan, fixer) {
+    const { moduleSpecifier, names, update } = plan;
+    if (update === void 0) {
+        return void 0;
+    }
+    const { defaultImportName, existingNamedImports, range } = update;
+    const mergedNames = [
+        ...new Set([...names, ...existingNamedImports]),
+    ].toSorted();
+    const statementText = buildImportStatement(moduleSpecifier, defaultImportName, mergedNames);
+    return fixer.replaceTextRange(range, statementText);
+}
+export { buildCombinedUpdateFixes };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+import type { RuleMatch } from "./types.js";
+/**
+ * Builds shared import fixes for every file match.
+ * @param matches Autofix contexts produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Import fixes de-duplicated by module and insertion site.
+ * @example
+ * ```typescript
+ * const fixes = buildCombinedImportFixes([], {} as never);
+ * void fixes;
+ * ```
+ */
+declare function buildCombinedImportFixes(matches: RuleMatch[], fixer: Rule.RuleFixer): Rule.Fix[];
+export { buildCombinedImportFixes };
+//# sourceMappingURL=fix-imports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix-imports.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAsDzC;;;;;;;;;;GAUG;AACH,iBAAS,wBAAwB,CAC/B,OAAO,EAAE,SAAS,EAAE,EACpB,KAAK,EAAE,IAAI,CAAC,SAAS,GACpB,IAAI,CAAC,GAAG,EAAE,CASZ;AAoND,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -0,0 +1,205 @@
+import { buildImportStatement } from "./fix-import-statements.js";
+import { buildCombinedUpdateFixes } from "./fix-import-updates.js";
+/**
+ * Adds one import statement to its insertion group.
+ * @param insertGroups Import statements grouped by insertion point.
+ * @param plan Combined import plan for one module.
+ * @example
+ * ```typescript
+ * addInsertStatement(new Map(), { moduleSpecifier: "./x", names: new Set(["a"]) } as never);
+ * ```
+ */
+function addInsertStatement(insertGroups, plan) {
+    const sortedNames = [...plan.names].toSorted();
+    if (sortedNames.length === 0 || plan.update !== void 0) {
+        return;
+    }
+    const key = getInsertGroupKey(plan.afterRange);
+    const group = insertGroups.get(key) ?? createInsertGroup(plan.afterRange);
+    group.statements.push(buildImportStatement(plan.moduleSpecifier, void 0, sortedNames));
+    group.statements.sort((left, right) => left.localeCompare(right));
+    insertGroups.set(key, group);
+}
+/**
+ * Builds shared import fixes for every file match.
+ * @param matches Autofix contexts produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Import fixes de-duplicated by module and insertion site.
+ * @example
+ * ```typescript
+ * const fixes = buildCombinedImportFixes([], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildCombinedImportFixes(matches, fixer) {
+    const newline = matches[0]?.newline ?? "\n";
+    const combinedPlans = combineImportPlans(matches);
+    const insertGroups = collectInsertGroups(combinedPlans);
+    return [
+        ...buildCombinedUpdateFixes(combinedPlans, fixer),
+        ...buildInsertGroupFixes(insertGroups, fixer, newline),
+    ];
+}
+/**
+ * Builds grouped insertion fixes for new imports.
+ * @param insertGroups Import statements grouped by insertion site.
+ * @param fixer ESLint fixer.
+ * @param newline Preferred file newline.
+ * @returns Insert fixes for new imports.
+ * @example
+ * ```typescript
+ * const fixes = buildInsertGroupFixes(new Map(), {} as never, "\n");
+ * void fixes;
+ * ```
+ */
+function buildInsertGroupFixes(insertGroups, fixer, newline) {
+    return [...insertGroups.values()].map((group) => group.afterRange === void 0
+        ? fixer.insertTextBeforeRange([0, 0], `${group.statements.join(newline)}${newline}${newline}`)
+        : fixer.insertTextAfterRange(group.afterRange, `${newline}${group.statements.join(newline)}`));
+}
+/**
+ * Collects insert groups keyed by insertion point.
+ * @param combinedPlans Combined plans keyed by module specifier.
+ * @returns Import statements grouped by insertion point.
+ * @example
+ * ```typescript
+ * const groups = collectInsertGroups(new Map());
+ * void groups;
+ * ```
+ */
+function collectInsertGroups(combinedPlans) {
+    const insertGroups = new Map();
+    for (const plan of combinedPlans.values()) {
+        addInsertStatement(insertGroups, plan);
+    }
+    return insertGroups;
+}
+/**
+ * Combines import plans across every file match.
+ * @param matches Autofix contexts produced by the matcher.
+ * @returns Combined plans keyed by module specifier.
+ * @example
+ * ```typescript
+ * const plans = combineImportPlans([]);
+ * void plans;
+ * ```
+ */
+function combineImportPlans(matches) {
+    const combinedPlans = new Map();
+    for (const match of matches) {
+        mergeImportPlan(combinedPlans, match);
+    }
+    return combinedPlans;
+}
+/**
+ * Creates the initial combined plan for one match.
+ * @param match Autofix context produced by the matcher.
+ * @returns Combined import plan seed.
+ * @example
+ * ```typescript
+ * const plan = createCombinedImportPlan({ moduleSpecifier: "./x", importPlan: { names: [] } } as never);
+ * void plan;
+ * ```
+ */
+function createCombinedImportPlan(match) {
+    const combinedPlan = {
+        moduleSpecifier: match.moduleSpecifier,
+        names: new Set(match.importPlan.names),
+    };
+    if (match.importPlan.insert?.afterRange !== void 0) {
+        combinedPlan.afterRange = match.importPlan.insert.afterRange;
+    }
+    if (match.importPlan.update !== void 0) {
+        combinedPlan.update = match.importPlan.update;
+    }
+    return combinedPlan;
+}
+/**
+ * Creates an insertion group for one location.
+ * @param afterRange Insert location for the group.
+ * @returns Insert group seed.
+ * @example
+ * ```typescript
+ * const group = createInsertGroup(void 0);
+ * void group;
+ * ```
+ */
+function createInsertGroup(afterRange) {
+    return afterRange === void 0
+        ? { statements: [] }
+        : { afterRange, statements: [] };
+}
+/**
+ * Creates a stable key for an insert location.
+ * @param afterRange Insert location when a new import must be inserted.
+ * @returns Stable key for the insertion site.
+ * @example
+ * ```typescript
+ * const key = getInsertGroupKey(void 0);
+ * void key;
+ * ```
+ */
+function getInsertGroupKey(afterRange) {
+    return afterRange === void 0 ? "TOP" : `${afterRange[0]}:${afterRange[1]}`;
+}
+/**
+ * Merges one match into the combined import-plan map.
+ * @param combinedPlans Combined plans keyed by module specifier.
+ * @param match Autofix context produced by the matcher.
+ * @example
+ * ```typescript
+ * mergeImportPlan(new Map(), {} as never);
+ * ```
+ */
+function mergeImportPlan(combinedPlans, match) {
+    const combinedPlan = combinedPlans.get(match.moduleSpecifier) ?? createCombinedImportPlan(match);
+    mergeImportPlanInsertRange(combinedPlan, match);
+    mergeImportPlanNames(combinedPlan, match.importPlan.names);
+    mergeImportPlanUpdate(combinedPlan, match);
+    combinedPlans.set(match.moduleSpecifier, combinedPlan);
+}
+/**
+ * Merges the first discovered insert range for a module.
+ * @param combinedPlan Combined plan for one module.
+ * @param match Autofix context produced by the matcher.
+ * @example
+ * ```typescript
+ * mergeImportPlanInsertRange({ moduleSpecifier: "./x", names: new Set() } as never, {} as never);
+ * ```
+ */
+function mergeImportPlanInsertRange(combinedPlan, match) {
+    if (combinedPlan.afterRange === void 0 &&
+        match.importPlan.insert?.afterRange !== void 0) {
+        combinedPlan.afterRange = match.importPlan.insert.afterRange;
+    }
+}
+/**
+ * Merges discovered import names for a module.
+ * @param combinedPlan Combined plan for one module.
+ * @param names Additional import names.
+ * @example
+ * ```typescript
+ * mergeImportPlanNames({ moduleSpecifier: "./x", names: new Set() } as never, ["a"]);
+ * ```
+ */
+function mergeImportPlanNames(combinedPlan, names) {
+    for (const name of names) {
+        combinedPlan.names.add(name);
+    }
+}
+/**
+ * Merges the first discovered update plan for a module.
+ * @param combinedPlan Combined plan for one module.
+ * @param match Autofix context produced by the matcher.
+ * @example
+ * ```typescript
+ * mergeImportPlanUpdate({ moduleSpecifier: "./x", names: new Set() } as never, {} as never);
+ * ```
+ */
+function mergeImportPlanUpdate(combinedPlan, match) {
+    if (combinedPlan.update === void 0 && match.importPlan.update !== void 0) {
+        combinedPlan.update = match.importPlan.update;
+    }
+}
+export { buildCombinedImportFixes };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fix-imports.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-imports.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { Range } from \"./match-helpers\";\r\nimport type { RuleMatch } from \"./types\";\r\n\r\nimport { buildImportStatement } from \"./fix-import-statements\";\r\nimport { buildCombinedUpdateFixes } from \"./fix-import-updates\";\r\n\r\n/** Combined import work for one module across all matches. */\r\ninterface CombinedImportPlan {\r\n  /** Insert location for a new import. */\r\n  afterRange?: Range;\r\n  /** Module imported by this plan. */\r\n  moduleSpecifier: string;\r\n  /** Named imports required for this module. */\r\n  names: Set<string>;\r\n  /** Existing import replacement plan when present. */\r\n  update?: NonNullable<RuleMatch[\"importPlan\"][\"update\"]>;\r\n}\r\n\r\n/** Import statements grouped by insertion point. */\r\ninterface InsertGroup {\r\n  /** Insert location for this group. */\r\n  afterRange?: Range;\r\n  /** Statements emitted at the same insertion point. */\r\n  statements: string[];\r\n}\r\n\r\n/**\r\n * Adds one import statement to its insertion group.\r\n * @param insertGroups Import statements grouped by insertion point.\r\n * @param plan Combined import plan for one module.\r\n * @example\r\n * ```typescript\r\n * addInsertStatement(new Map(), { moduleSpecifier: \"./x\", names: new Set([\"a\"]) } as never);\r\n * ```\r\n */\r\nfunction addInsertStatement(\r\n  insertGroups: Map<string, InsertGroup>,\r\n  plan: CombinedImportPlan,\r\n): void {\r\n  const sortedNames = [...plan.names].toSorted();\r\n\r\n  if (sortedNames.length === 0 || plan.update !== void 0) {\r\n    return;\r\n  }\r\n\r\n  const key = getInsertGroupKey(plan.afterRange);\r\n  const group = insertGroups.get(key) ?? createInsertGroup(plan.afterRange);\r\n\r\n  group.statements.push(\r\n    buildImportStatement(plan.moduleSpecifier, void 0, sortedNames),\r\n  );\r\n  group.statements.sort((left, right) => left.localeCompare(right));\r\n  insertGroups.set(key, group);\r\n}\r\n\r\n/**\r\n * Builds shared import fixes for every file match.\r\n * @param matches Autofix contexts produced by the matcher.\r\n * @param fixer ESLint fixer.\r\n * @returns Import fixes de-duplicated by module and insertion site.\r\n * @example\r\n * ```typescript\r\n * const fixes = buildCombinedImportFixes([], {} as never);\r\n * void fixes;\r\n * ```\r\n */\r\nfunction buildCombinedImportFixes(\r\n  matches: RuleMatch[],\r\n  fixer: Rule.RuleFixer,\r\n): Rule.Fix[] {\r\n  const newline = matches[0]?.newline ?? \"\\n\";\r\n  const combinedPlans = combineImportPlans(matches);\r\n  const insertGroups = collectInsertGroups(combinedPlans);\r\n\r\n  return [\r\n    ...buildCombinedUpdateFixes(combinedPlans, fixer),\r\n    ...buildInsertGroupFixes(insertGroups, fixer, newline),\r\n  ];\r\n}\r\n\r\n/**\r\n * Builds grouped insertion fixes for new imports.\r\n * @param insertGroups Import statements grouped by insertion site.\r\n * @param fixer ESLint fixer.\r\n * @param newline Preferred file newline.\r\n * @returns Insert fixes for new imports.\r\n * @example\r\n * ```typescript\r\n * const fixes = buildInsertGroupFixes(new Map(), {} as never, \"\\n\");\r\n * void fixes;\r\n * ```\r\n */\r\nfunction buildInsertGroupFixes(\r\n  insertGroups: Map<string, InsertGroup>,\r\n  fixer: Rule.RuleFixer,\r\n  newline: \"\\n\" | \"\\r\\n\",\r\n): Rule.Fix[] {\r\n  return [...insertGroups.values()].map((group) =>\r\n    group.afterRange === void 0\r\n      ? fixer.insertTextBeforeRange(\r\n          [0, 0],\r\n          `${group.statements.join(newline)}${newline}${newline}`,\r\n        )\r\n      : fixer.insertTextAfterRange(\r\n          group.afterRange,\r\n          `${newline}${group.statements.join(newline)}`,\r\n        ),\r\n  );\r\n}\r\n\r\n/**\r\n * Collects insert groups keyed by insertion point.\r\n * @param combinedPlans Combined plans keyed by module specifier.\r\n * @returns Import statements grouped by insertion point.\r\n * @example\r\n * ```typescript\r\n * const groups = collectInsertGroups(new Map());\r\n * void groups;\r\n * ```\r\n */\r\nfunction collectInsertGroups(\r\n  combinedPlans: Map<string, CombinedImportPlan>,\r\n): Map<string, InsertGroup> {\r\n  const insertGroups = new Map<string, InsertGroup>();\r\n\r\n  for (const plan of combinedPlans.values()) {\r\n    addInsertStatement(insertGroups, plan);\r\n  }\r\n\r\n  return insertGroups;\r\n}\r\n\r\n/**\r\n * Combines import plans across every file match.\r\n * @param matches Autofix contexts produced by the matcher.\r\n * @returns Combined plans keyed by module specifier.\r\n * @example\r\n * ```typescript\r\n * const plans = combineImportPlans([]);\r\n * void plans;\r\n * ```\r\n */\r\nfunction combineImportPlans(\r\n  matches: RuleMatch[],\r\n): Map<string, CombinedImportPlan> {\r\n  const combinedPlans = new Map<string, CombinedImportPlan>();\r\n\r\n  for (const match of matches) {\r\n    mergeImportPlan(combinedPlans, match);\r\n  }\r\n\r\n  return combinedPlans;\r\n}\r\n\r\n/**\r\n * Creates the initial combined plan for one match.\r\n * @param match Autofix context produced by the matcher.\r\n * @returns Combined import plan seed.\r\n * @example\r\n * ```typescript\r\n * const plan = createCombinedImportPlan({ moduleSpecifier: \"./x\", importPlan: { names: [] } } as never);\r\n * void plan;\r\n * ```\r\n */\r\nfunction createCombinedImportPlan(match: RuleMatch): CombinedImportPlan {\r\n  const combinedPlan: CombinedImportPlan = {\r\n    moduleSpecifier: match.moduleSpecifier,\r\n    names: new Set(match.importPlan.names),\r\n  };\r\n\r\n  if (match.importPlan.insert?.afterRange !== void 0) {\r\n    combinedPlan.afterRange = match.importPlan.insert.afterRange;\r\n  }\r\n\r\n  if (match.importPlan.update !== void 0) {\r\n    combinedPlan.update = match.importPlan.update;\r\n  }\r\n\r\n  return combinedPlan;\r\n}\r\n\r\n/**\r\n * Creates an insertion group for one location.\r\n * @param afterRange Insert location for the group.\r\n * @returns Insert group seed.\r\n * @example\r\n * ```typescript\r\n * const group = createInsertGroup(void 0);\r\n * void group;\r\n * ```\r\n */\r\nfunction createInsertGroup(afterRange: Range | undefined): InsertGroup {\r\n  return afterRange === void 0\r\n    ? { statements: [] }\r\n    : { afterRange, statements: [] };\r\n}\r\n\r\n/**\r\n * Creates a stable key for an insert location.\r\n * @param afterRange Insert location when a new import must be inserted.\r\n * @returns Stable key for the insertion site.\r\n * @example\r\n * ```typescript\r\n * const key = getInsertGroupKey(void 0);\r\n * void key;\r\n * ```\r\n */\r\nfunction getInsertGroupKey(afterRange: Range | undefined): string {\r\n  return afterRange === void 0 ? \"TOP\" : `${afterRange[0]}:${afterRange[1]}`;\r\n}\r\n\r\n/**\r\n * Merges one match into the combined import-plan map.\r\n * @param combinedPlans Combined plans keyed by module specifier.\r\n * @param match Autofix context produced by the matcher.\r\n * @example\r\n * ```typescript\r\n * mergeImportPlan(new Map(), {} as never);\r\n * ```\r\n */\r\nfunction mergeImportPlan(\r\n  combinedPlans: Map<string, CombinedImportPlan>,\r\n  match: RuleMatch,\r\n): void {\r\n  const combinedPlan =\r\n    combinedPlans.get(match.moduleSpecifier) ?? createCombinedImportPlan(match);\r\n\r\n  mergeImportPlanInsertRange(combinedPlan, match);\r\n  mergeImportPlanNames(combinedPlan, match.importPlan.names);\r\n  mergeImportPlanUpdate(combinedPlan, match);\r\n  combinedPlans.set(match.moduleSpecifier, combinedPlan);\r\n}\r\n\r\n/**\r\n * Merges the first discovered insert range for a module.\r\n * @param combinedPlan Combined plan for one module.\r\n * @param match Autofix context produced by the matcher.\r\n * @example\r\n * ```typescript\r\n * mergeImportPlanInsertRange({ moduleSpecifier: \"./x\", names: new Set() } as never, {} as never);\r\n * ```\r\n */\r\nfunction mergeImportPlanInsertRange(\r\n  combinedPlan: CombinedImportPlan,\r\n  match: RuleMatch,\r\n): void {\r\n  if (\r\n    combinedPlan.afterRange === void 0 &&\r\n    match.importPlan.insert?.afterRange !== void 0\r\n  ) {\r\n    combinedPlan.afterRange = match.importPlan.insert.afterRange;\r\n  }\r\n}\r\n\r\n/**\r\n * Merges discovered import names for a module.\r\n * @param combinedPlan Combined plan for one module.\r\n * @param names Additional import names.\r\n * @example\r\n * ```typescript\r\n * mergeImportPlanNames({ moduleSpecifier: \"./x\", names: new Set() } as never, [\"a\"]);\r\n * ```\r\n */\r\nfunction mergeImportPlanNames(\r\n  combinedPlan: CombinedImportPlan,\r\n  names: string[],\r\n): void {\r\n  for (const name of names) {\r\n    combinedPlan.names.add(name);\r\n  }\r\n}\r\n\r\n/**\r\n * Merges the first discovered update plan for a module.\r\n * @param combinedPlan Combined plan for one module.\r\n * @param match Autofix context produced by the matcher.\r\n * @example\r\n * ```typescript\r\n * mergeImportPlanUpdate({ moduleSpecifier: \"./x\", names: new Set() } as never, {} as never);\r\n * ```\r\n */\r\nfunction mergeImportPlanUpdate(\r\n  combinedPlan: CombinedImportPlan,\r\n  match: RuleMatch,\r\n): void {\r\n  if (combinedPlan.update === void 0 && match.importPlan.update !== void 0) {\r\n    combinedPlan.update = match.importPlan.update;\r\n  }\r\n}\r\n\r\nexport { buildCombinedImportFixes };\r\n"]}