@codeperfect/eslint-plugin 1.0.0

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

@@ -0,0 +1,16 @@
+import type * as ESTree from "estree";
+import type { Binding, Declaration } from "./types";
+/**
+ * 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;
+ * ```
+ */
+declare function collectBindings(objectExpression: ESTree.ObjectExpression, declarations: Map<string, Declaration>): Binding[];
+export { collectBindings };
+//# sourceMappingURL=match-bindings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-bindings.d.ts","sourceRoot":"","sources":["../../../src/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/testing/prefer-vi-mocked-import/match-bindings.js

@@ -0,0 +1,52 @@
+import { hasRange } from "./match-helpers";
+/**
+ * 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/prefer-vi-mocked-import/match-declarations.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+import type * as ESTree from "estree";
+import type { Declaration } from "./types";
+/**
+ * Collects top-level `const x = vi.fn(...)` declarations.
+ * @param program Program node.
+ * @returns Declarations by local name.
+ * @example
+ * ```typescript
+ * const declarations = collectDeclarations({ body: [], sourceType: "module", type: "Program" } as never);
+ * void declarations;
+ * ```
+ */
+declare function collectDeclarations(program: ESTree.Program, sourceCode?: Rule.RuleContext["sourceCode"]): Map<string, Declaration>;
+export { collectDeclarations };
+//# sourceMappingURL=match-declarations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-declarations.d.ts","sourceRoot":"","sources":["../../../src/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;;;;;;;;;GASG;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;AAwGD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

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

@@ -0,0 +1,99 @@
+import { hasRange, isViFunctionCall } from "./match-helpers";
+/**
+ * Collects top-level `const x = vi.fn(...)` declarations.
+ * @param program Program node.
+ * @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]));
+}
+/**
+ * Converts one top-level statement into a declaration when supported.
+ * @param statement Candidate statement.
+ * @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),
+    };
+}
+/**
+ * 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 = statement.range[0];
+    const commentsBefore = sourceCode?.getCommentsBefore(statement) ?? [];
+    if (commentsBefore.length === 0) {
+        return statement.range;
+    }
+    let removalStart = statementStart;
+    let nextStart = statementStart;
+    for (const comment of [...commentsBefore].reverse()) {
+        const commentRange = comment.range;
+        if (commentRange === void 0) {
+            break;
+        }
+        const gapText = sourceCode?.text.slice(commentRange[1], nextStart) ?? "";
+        if (!isAttachedLeadingGap(gapText)) {
+            break;
+        }
+        removalStart = commentRange[0];
+        nextStart = commentRange[0];
+    }
+    return [removalStart, statement.range[1]];
+}
+/**
+ * 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));
+}
+export { collectDeclarations };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match-declarations.js","sourceRoot":"","sources":["../../../src/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 * @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 * Converts one top-level statement into a declaration when supported.\n * @param statement Candidate statement.\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\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 & { range: [number, number] },\n  sourceCode?: Rule.RuleContext[\"sourceCode\"],\n): [number, number] {\n  const statementStart = statement.range[0];\n  const commentsBefore = sourceCode?.getCommentsBefore(statement) ?? [];\n\n  if (commentsBefore.length === 0) {\n    return statement.range;\n  }\n\n  let removalStart = statementStart;\n  let nextStart = statementStart;\n\n  for (const comment of [...commentsBefore].reverse()) {\n    const commentRange = comment.range;\n\n    if (commentRange === void 0) {\n      break;\n    }\n\n    const gapText = sourceCode?.text.slice(commentRange[1], nextStart) ?? \"\";\n    if (!isAttachedLeadingGap(gapText)) {\n      break;\n    }\n\n    removalStart = commentRange[0];\n    nextStart = commentRange[0];\n  }\n\n  return [removalStart, statement.range[1]];\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\nexport { collectDeclarations };\n"]}

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

@@ -0,0 +1,66 @@
+import type * as ESTree from "estree";
+/** Type definition for rule data. */
+type Range = [number, number];
+/** Type definition for rule data. */
+type RangeNode = ESTree.Node & {
+    /** Source range tuple for the node. */
+    range: Range;
+};
+/**
+ * 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;
+ * ```
+ */
+declare function getFactoryReturnObject(factoryExpression: ESTree.Expression): ESTree.ObjectExpression | undefined;
+/**
+ * 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;
+ * ```
+ */
+declare function getModuleSpecifier(moduleArgument: ESTree.Expression): string | undefined;
+/**
+ * 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;
+ * ```
+ */
+declare function getNewline(sourceText: string): "\n" | "\r\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;
+ * ```
+ */
+declare function hasRange(node: ESTree.Node): node is RangeNode;
+/**
+ * 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;
+ * ```
+ */
+declare function isViFunctionCall(expression: ESTree.Expression | null): boolean;
+export type { Range };
+export { getFactoryReturnObject, getModuleSpecifier, getNewline, hasRange, isViFunctionCall, };
+//# sourceMappingURL=match-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-helpers.d.ts","sourceRoot":"","sources":["../../../src/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/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/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/prefer-vi-mocked-import/match-imports.d.ts

@@ -0,0 +1,17 @@
+import type * as ESTree from "estree";
+import type { ImportPlan } from "./types";
+/**
+ * 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;
+ * ```
+ */
+declare function resolveImportPlan(program: ESTree.Program, moduleSpecifier: string, names: string[]): ImportPlan;
+export { resolveImportPlan };
+//# sourceMappingURL=match-imports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-imports.d.ts","sourceRoot":"","sources":["../../../src/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/testing/prefer-vi-mocked-import/match-imports.js

@@ -0,0 +1,156 @@
+import { hasRange } from "./match-helpers";
+/**
+ * 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/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/prefer-vi-mocked-import/match-rewrites.d.ts

@@ -0,0 +1,42 @@
+import type * as ESTree from "estree";
+import type { Binding, Declaration, MemberRewrite } from "./types";
+/**
+ * Returns false if a binding local is used outside allowed rewrite sites.
+ * @param program Program node containing mock usage.
+ * @param allowedIdentifierRanges Identifier ranges that are safe to rewrite.
+ * @param localNames Local names tracked by the matcher.
+ * @returns True when all local usages are safe.
+ * @example
+ * ```typescript
+ * const safe = areLocalsSafeToInline({ body: [], sourceType: "module", type: "Program" } as never, new Set(), new Set());
+ * void safe;
+ * ```
+ */
+declare function areLocalsSafeToInline(program: ESTree.Program, allowedIdentifierRanges: Set<string>, localNames: Set<string>): boolean;
+/**
+ * Builds a set of allowed identifier ranges for safe-inline validation.
+ * @param bindings Bindings list.
+ * @param declarations Declarations map.
+ * @param rewrites Member rewrites.
+ * @returns Allowed identifier range keys.
+ * @example
+ * ```typescript
+ * const ranges = buildAllowedRanges([], new Map(), []);
+ * void ranges;
+ * ```
+ */
+declare function buildAllowedRanges(bindings: Binding[], declarations: Map<string, Declaration>, rewrites: MemberRewrite[]): Set<string>;
+/**
+ * Collects member-expression object rewrites for `.mock*` calls.
+ * @param program Program node.
+ * @param localToExported Local to exported name map.
+ * @returns Collected member rewrites.
+ * @example
+ * ```typescript
+ * const rewrites = collectMemberRewrites({ body: [], sourceType: "module", type: "Program" } as never, new Map());
+ * void rewrites;
+ * ```
+ */
+declare function collectMemberRewrites(program: ESTree.Program, localToExported: Map<string, string>): MemberRewrite[];
+export { areLocalsSafeToInline, buildAllowedRanges, collectMemberRewrites };
+//# sourceMappingURL=match-rewrites.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-rewrites.d.ts","sourceRoot":"","sources":["../../../src/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"}