@codeperfect/eslint-plugin 1.0.0 → 2.1.0

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,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

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"}

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

@@ -0,0 +1,156 @@
+import { hasRange } from "./match-helpers.js";
+/**
+ * Builds an import plan for insertion mode.
+ * @param moduleSpecifier Target module path.
+ * @param names Names to import.
+ * @param afterRange Range to insert after.
+ * @returns Insert plan payload.
+ * @example
+ * ```typescript
+ * const plan = createInsertPlan("./x", ["a"], [0, 1]);
+ * void plan;
+ * ```
+ */
+function createInsertPlan(moduleSpecifier, names, afterRange) {
+    return afterRange === void 0
+        ? { insert: {}, moduleSpecifier, names }
+        : { insert: { afterRange }, moduleSpecifier, names };
+}
+/**
+ * Builds an import plan for update mode.
+ * @param statement Existing import declaration.
+ * @param moduleSpecifier Target module path.
+ * @param names Names to import.
+ * @returns Update plan payload.
+ * @example
+ * ```typescript
+ * const plan = createUpdatePlan({ specifiers: [], source: { type: "Literal", value: "./x" }, type: "ImportDeclaration", range: [0, 1] } as never, "./x", ["a"]);
+ * void plan;
+ * ```
+ */
+function createUpdatePlan(statement, moduleSpecifier, names) {
+    if (hasNamespaceImport(statement)) {
+        return createInsertPlan(moduleSpecifier, names, statement.range);
+    }
+    const defaultImportName = getDefaultImportName(statement);
+    const baseUpdate = {
+        existingNamedImports: getNamedImports(statement),
+        range: statement.range,
+    };
+    const update = defaultImportName === void 0
+        ? baseUpdate
+        : { ...baseUpdate, defaultImportName };
+    return {
+        moduleSpecifier,
+        names,
+        update,
+    };
+}
+/**
+ * Returns the default import local name.
+ * @param statement Import declaration.
+ * @returns Default local name when present.
+ * @example
+ * ```typescript
+ * const localName = getDefaultImportName({ specifiers: [], type: "ImportDeclaration" } as never);
+ * void localName;
+ * ```
+ */
+function getDefaultImportName(statement) {
+    const defaultSpecifier = statement.specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier");
+    return defaultSpecifier?.local.name;
+}
+/**
+ * Filters top-level import declarations that include a `range`.
+ * @param program Program node.
+ * @returns Import declarations with stable ranges.
+ * @example
+ * ```typescript
+ * const imports = getImportDeclarations({ body: [], sourceType: "module", type: "Program" } as never);
+ * void imports;
+ * ```
+ */
+function getImportDeclarations(program) {
+    return program.body.filter((statement) => statement.type === "ImportDeclaration" && hasRange(statement));
+}
+/**
+ * Returns all named imports from a declaration.
+ * @param statement Import declaration.
+ * @returns Named import identifiers.
+ * @example
+ * ```typescript
+ * const named = getNamedImports({ specifiers: [], type: "ImportDeclaration" } as never);
+ * void named;
+ * ```
+ */
+function getNamedImports(statement) {
+    return statement.specifiers.flatMap((specifier) => {
+        const importedName = toImportedName(specifier);
+        return importedName === void 0 ? [] : [importedName];
+    });
+}
+/**
+ * Checks whether an import includes a namespace specifier.
+ * @param statement Import declaration.
+ * @returns True when declaration includes `* as x` form.
+ * @example
+ * ```typescript
+ * const hasNamespace = hasNamespaceImport({ specifiers: [], type: "ImportDeclaration" } as never);
+ * void hasNamespace;
+ * ```
+ */
+function hasNamespaceImport(statement) {
+    return statement.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier");
+}
+/**
+ * Checks whether an import declaration matches the mocked module.
+ * @param statement Import declaration candidate.
+ * @param moduleSpecifier Expected module path.
+ * @returns True when declaration targets the same module.
+ * @example
+ * ```typescript
+ * const matched = isMatchingImport({ source: { type: "Literal", value: "./x" }, type: "ImportDeclaration" } as never, "./x");
+ * void matched;
+ * ```
+ */
+function isMatchingImport(statement, moduleSpecifier) {
+    const sourceValue = statement.source.value;
+    return typeof sourceValue === "string" && sourceValue === moduleSpecifier;
+}
+/**
+ * Resolves whether imports should be updated in place or inserted.
+ * @param program Program node to inspect.
+ * @param moduleSpecifier Target module path.
+ * @param names Import names that must exist.
+ * @returns Insert or update plan for the import section.
+ * @example
+ * ```typescript
+ * const plan = resolveImportPlan({ body: [], sourceType: "module", type: "Program" } as never, "./x", ["a"]);
+ * void plan;
+ * ```
+ */
+function resolveImportPlan(program, moduleSpecifier, names) {
+    const imports = getImportDeclarations(program);
+    const existingImport = imports.find((statement) => isMatchingImport(statement, moduleSpecifier));
+    return existingImport === void 0
+        ? createInsertPlan(moduleSpecifier, names, imports.at(-1)?.range)
+        : createUpdatePlan(existingImport, moduleSpecifier, names);
+}
+/**
+ * Extracts imported identifier name from one specifier.
+ * @param specifier Import clause entry.
+ * @returns Imported identifier name.
+ * @example
+ * ```typescript
+ * const imported = toImportedName({ type: "ImportSpecifier", imported: { type: "Identifier", name: "x" } } as never);
+ * void imported;
+ * ```
+ */
+function toImportedName(specifier) {
+    return specifier.type === "ImportSpecifier" &&
+        specifier.imported.type === "Identifier"
+        ? specifier.imported.name
+        : void 0;
+}
+export { resolveImportPlan };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match-imports.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-imports.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\n\nimport type { Range } from \"./match-helpers\";\nimport type { ImportPlan } from \"./types\";\n\nimport { hasRange } from \"./match-helpers\";\n\n/**\n * Type definition for rule data.\n * @example\n * ```typescript\n * const declaration = {} as RangedImportDeclaration;\n * void declaration;\n * ```\n */\ninterface RangedImportDeclaration extends ESTree.ImportDeclaration {\n  /** Import declaration source range. */\n  range: Range;\n}\n\n/**\n * Builds an import plan for insertion mode.\n * @param moduleSpecifier Target module path.\n * @param names Names to import.\n * @param afterRange Range to insert after.\n * @returns Insert plan payload.\n * @example\n * ```typescript\n * const plan = createInsertPlan(\"./x\", [\"a\"], [0, 1]);\n * void plan;\n * ```\n */\nfunction createInsertPlan(\n  moduleSpecifier: string,\n  names: string[],\n  afterRange: Range | undefined,\n): ImportPlan {\n  return afterRange === void 0\n    ? { insert: {}, moduleSpecifier, names }\n    : { insert: { afterRange }, moduleSpecifier, names };\n}\n\n/**\n * Builds an import plan for update mode.\n * @param statement Existing import declaration.\n * @param moduleSpecifier Target module path.\n * @param names Names to import.\n * @returns Update plan payload.\n * @example\n * ```typescript\n * const plan = createUpdatePlan({ specifiers: [], source: { type: \"Literal\", value: \"./x\" }, type: \"ImportDeclaration\", range: [0, 1] } as never, \"./x\", [\"a\"]);\n * void plan;\n * ```\n */\nfunction createUpdatePlan(\n  statement: RangedImportDeclaration,\n  moduleSpecifier: string,\n  names: string[],\n): ImportPlan {\n  if (hasNamespaceImport(statement)) {\n    return createInsertPlan(moduleSpecifier, names, statement.range);\n  }\n\n  const defaultImportName = getDefaultImportName(statement);\n  const baseUpdate = {\n    existingNamedImports: getNamedImports(statement),\n    range: statement.range,\n  };\n  const update =\n    defaultImportName === void 0\n      ? baseUpdate\n      : { ...baseUpdate, defaultImportName };\n\n  return {\n    moduleSpecifier,\n    names,\n    update,\n  };\n}\n\n/**\n * Returns the default import local name.\n * @param statement Import declaration.\n * @returns Default local name when present.\n * @example\n * ```typescript\n * const localName = getDefaultImportName({ specifiers: [], type: \"ImportDeclaration\" } as never);\n * void localName;\n * ```\n */\nfunction getDefaultImportName(\n  statement: ESTree.ImportDeclaration,\n): string | undefined {\n  const defaultSpecifier = statement.specifiers.find(\n    (specifier): specifier is ESTree.ImportDefaultSpecifier =>\n      specifier.type === \"ImportDefaultSpecifier\",\n  );\n  return defaultSpecifier?.local.name;\n}\n\n/**\n * Filters top-level import declarations that include a `range`.\n * @param program Program node.\n * @returns Import declarations with stable ranges.\n * @example\n * ```typescript\n * const imports = getImportDeclarations({ body: [], sourceType: \"module\", type: \"Program\" } as never);\n * void imports;\n * ```\n */\nfunction getImportDeclarations(\n  program: ESTree.Program,\n): RangedImportDeclaration[] {\n  return program.body.filter(\n    (statement): statement is RangedImportDeclaration =>\n      statement.type === \"ImportDeclaration\" && hasRange(statement),\n  );\n}\n\n/**\n * Returns all named imports from a declaration.\n * @param statement Import declaration.\n * @returns Named import identifiers.\n * @example\n * ```typescript\n * const named = getNamedImports({ specifiers: [], type: \"ImportDeclaration\" } as never);\n * void named;\n * ```\n */\nfunction getNamedImports(statement: ESTree.ImportDeclaration): string[] {\n  return statement.specifiers.flatMap((specifier) => {\n    const importedName = toImportedName(specifier);\n    return importedName === void 0 ? [] : [importedName];\n  });\n}\n\n/**\n * Checks whether an import includes a namespace specifier.\n * @param statement Import declaration.\n * @returns True when declaration includes `* as x` form.\n * @example\n * ```typescript\n * const hasNamespace = hasNamespaceImport({ specifiers: [], type: \"ImportDeclaration\" } as never);\n * void hasNamespace;\n * ```\n */\nfunction hasNamespaceImport(statement: ESTree.ImportDeclaration): boolean {\n  return statement.specifiers.some(\n    (specifier) => specifier.type === \"ImportNamespaceSpecifier\",\n  );\n}\n\n/**\n * Checks whether an import declaration matches the mocked module.\n * @param statement Import declaration candidate.\n * @param moduleSpecifier Expected module path.\n * @returns True when declaration targets the same module.\n * @example\n * ```typescript\n * const matched = isMatchingImport({ source: { type: \"Literal\", value: \"./x\" }, type: \"ImportDeclaration\" } as never, \"./x\");\n * void matched;\n * ```\n */\nfunction isMatchingImport(\n  statement: ESTree.ImportDeclaration,\n  moduleSpecifier: string,\n): boolean {\n  const sourceValue = statement.source.value;\n  return typeof sourceValue === \"string\" && sourceValue === moduleSpecifier;\n}\n\n/**\n * Resolves whether imports should be updated in place or inserted.\n * @param program Program node to inspect.\n * @param moduleSpecifier Target module path.\n * @param names Import names that must exist.\n * @returns Insert or update plan for the import section.\n * @example\n * ```typescript\n * const plan = resolveImportPlan({ body: [], sourceType: \"module\", type: \"Program\" } as never, \"./x\", [\"a\"]);\n * void plan;\n * ```\n */\nfunction resolveImportPlan(\n  program: ESTree.Program,\n  moduleSpecifier: string,\n  names: string[],\n): ImportPlan {\n  const imports = getImportDeclarations(program);\n  const existingImport = imports.find((statement) =>\n    isMatchingImport(statement, moduleSpecifier),\n  );\n\n  return existingImport === void 0\n    ? createInsertPlan(moduleSpecifier, names, imports.at(-1)?.range)\n    : createUpdatePlan(existingImport, moduleSpecifier, names);\n}\n\n/**\n * Extracts imported identifier name from one specifier.\n * @param specifier Import clause entry.\n * @returns Imported identifier name.\n * @example\n * ```typescript\n * const imported = toImportedName({ type: \"ImportSpecifier\", imported: { type: \"Identifier\", name: \"x\" } } as never);\n * void imported;\n * ```\n */\nfunction toImportedName(\n  specifier: ESTree.ImportDeclaration[\"specifiers\"][number],\n): string | undefined {\n  return specifier.type === \"ImportSpecifier\" &&\n    specifier.imported.type === \"Identifier\"\n    ? specifier.imported.name\n    : void 0;\n}\n\nexport { resolveImportPlan };\n"]}

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

@@ -1,5 +1,5 @@
 import type * as ESTree from "estree";
-import type { Binding, Declaration, MemberRewrite } from "./types";
+import type { Binding, Declaration, MemberRewrite } from "./types.js";
 /**
  * Returns false if a binding local is used outside allowed rewrite sites.
  * @param program Program node containing mock usage.

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-rewrites.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-rewrites.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAyBnE;;;;;;;;;;;GAWG;AACH,iBAAS,qBAAqB,CAC5B,OAAO,EAAE,MAAM,CAAC,OAAO,EACvB,uBAAuB,EAAE,GAAG,CAAC,MAAM,CAAC,EACpC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,OAAO,CAkBT;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,kBAAkB,CACzB,QAAQ,EAAE,OAAO,EAAE,EACnB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACtC,QAAQ,EAAE,aAAa,EAAE,GACxB,GAAG,CAAC,MAAM,CAAC,CAkBb;AAED;;;;;;;;;;GAUG;AACH,iBAAS,qBAAqB,CAC5B,OAAO,EAAE,MAAM,CAAC,OAAO,EACvB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,aAAa,EAAE,CAUjB;AAqCD,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,CAAC"}