@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAe3C;;;;;;;;;;;GAWG;AACH,SAAS,gBAAgB,CACvB,eAAuB,EACvB,KAAe,EACf,UAA6B;IAE7B,OAAO,UAAU,KAAK,KAAK,CAAC;QAC1B,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE;QACxC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,gBAAgB,CACvB,SAAkC,EAClC,eAAuB,EACvB,KAAe;IAEf,IAAI,kBAAkB,CAAC,SAAS,CAAC,EAAE,CAAC;QAClC,OAAO,gBAAgB,CAAC,eAAe,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,SAAS,CAAC,CAAC;IAC1D,MAAM,UAAU,GAAG;QACjB,oBAAoB,EAAE,eAAe,CAAC,SAAS,CAAC;QAChD,KAAK,EAAE,SAAS,CAAC,KAAK;KACvB,CAAC;IACF,MAAM,MAAM,GACV,iBAAiB,KAAK,KAAK,CAAC;QAC1B,CAAC,CAAC,UAAU;QACZ,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAE3C,OAAO;QACL,eAAe;QACf,KAAK;QACL,MAAM;KACP,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,oBAAoB,CAC3B,SAAmC;IAEnC,MAAM,gBAAgB,GAAG,SAAS,CAAC,UAAU,CAAC,IAAI,CAChD,CAAC,SAAS,EAA8C,EAAE,CACxD,SAAS,CAAC,IAAI,KAAK,wBAAwB,CAC9C,CAAC;IACF,OAAO,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC;AACtC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,qBAAqB,CAC5B,OAAuB;IAEvB,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CACxB,CAAC,SAAS,EAAwC,EAAE,CAClD,SAAS,CAAC,IAAI,KAAK,mBAAmB,IAAI,QAAQ,CAAC,SAAS,CAAC,CAChE,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,eAAe,CAAC,SAAmC;IAC1D,OAAO,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;QAChD,MAAM,YAAY,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC;QAC/C,OAAO,YAAY,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,kBAAkB,CAAC,SAAmC;IAC7D,OAAO,SAAS,CAAC,UAAU,CAAC,IAAI,CAC9B,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,0BAA0B,CAC7D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,gBAAgB,CACvB,SAAmC,EACnC,eAAuB;IAEvB,MAAM,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3C,OAAO,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,eAAe,CAAC;AAC5E,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,iBAAiB,CACxB,OAAuB,EACvB,eAAuB,EACvB,KAAe;IAEf,MAAM,OAAO,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;IAC/C,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAChD,gBAAgB,CAAC,SAAS,EAAE,eAAe,CAAC,CAC7C,CAAC;IAEF,OAAO,cAAc,KAAK,KAAK,CAAC;QAC9B,CAAC,CAAC,gBAAgB,CAAC,eAAe,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;QACjE,CAAC,CAAC,gBAAgB,CAAC,cAAc,EAAE,eAAe,EAAE,KAAK,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,cAAc,CACrB,SAAyD;IAEzD,OAAO,SAAS,CAAC,IAAI,KAAK,iBAAiB;QACzC,SAAS,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;QACxC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI;QACzB,CAAC,CAAC,KAAK,CAAC,CAAC;AACb,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC","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"}

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

@@ -0,0 +1,119 @@
+import { hasRange } from "./match-helpers.js";
+import { walkNode } from "./match-walk.js";
+/**
+ * Adds declaration identifier range to the allowed set.
+ * @param allowedRanges Allowed range set.
+ * @param declaration Declaration to include.
+ * @example
+ * ```typescript
+ * const allowed = new Set<string>();
+ * addDeclarationIdRange(allowed, void 0);
+ * ```
+ */
+function addDeclarationIdRange(allowedRanges, declaration) {
+    if (declaration !== void 0) {
+        const rangeKey = `${declaration.declarationIdRange[0]}:${declaration.declarationIdRange[1]}`;
+        allowedRanges.add(rangeKey);
+    }
+}
+/**
+ * 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;
+ * ```
+ */
+function areLocalsSafeToInline(program, allowedIdentifierRanges, localNames) {
+    let isSafe = true;
+    walkNode(program, (currentNode) => {
+        if (!isSafe ||
+            currentNode.type !== "Identifier" ||
+            !hasRange(currentNode)) {
+            return;
+        }
+        const key = `${currentNode.range[0]}:${currentNode.range[1]}`;
+        if (localNames.has(currentNode.name) && !allowedIdentifierRanges.has(key)) {
+            isSafe = false;
+        }
+    });
+    return isSafe;
+}
+/**
+ * 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;
+ * ```
+ */
+function buildAllowedRanges(bindings, declarations, rewrites) {
+    const allowedRanges = new Set();
+    for (const binding of bindings) {
+        allowedRanges.add(`${binding.propertyKeyRange[0]}:${binding.propertyKeyRange[1]}`);
+        allowedRanges.add(`${binding.propertyValueRange[0]}:${binding.propertyValueRange[1]}`);
+        addDeclarationIdRange(allowedRanges, declarations.get(binding.localName));
+    }
+    for (const rewrite of rewrites) {
+        allowedRanges.add(`${rewrite.localObjectRange[0]}:${rewrite.localObjectRange[1]}`);
+    }
+    return allowedRanges;
+}
+/**
+ * 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;
+ * ```
+ */
+function collectMemberRewrites(program, localToExported) {
+    const rewrites = [];
+    walkNode(program, (currentNode) => {
+        const rewrite = toMemberRewrite(currentNode, localToExported);
+        if (rewrite !== void 0) {
+            rewrites.push(rewrite);
+        }
+    });
+    return rewrites;
+}
+/**
+ * Converts a node into a member rewrite when supported.
+ * @param currentNode Candidate node.
+ * @param localToExported Local to exported name map.
+ * @returns Member rewrite when node is supported.
+ * @example
+ * ```typescript
+ * const rewrite = toMemberRewrite({ type: "Identifier", name: "x" } as never, new Map());
+ * void rewrite;
+ * ```
+ */
+function toMemberRewrite(currentNode, localToExported) {
+    if (currentNode.type !== "MemberExpression") {
+        return void 0;
+    }
+    const { object, property } = currentNode;
+    if (object.type !== "Identifier" ||
+        !hasRange(object) ||
+        property.type !== "Identifier" ||
+        !property.name.startsWith("mock")) {
+        return void 0;
+    }
+    const exportedName = localToExported.get(object.name);
+    return exportedName === void 0
+        ? void 0
+        : { exportedName, localObjectRange: object.range };
+}
+export { areLocalsSafeToInline, buildAllowedRanges, collectMemberRewrites };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match-rewrites.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-rewrites.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC;;;;;;;;;GASG;AACH,SAAS,qBAAqB,CAC5B,aAA0B,EAC1B,WAAoC;IAEpC,IAAI,WAAW,KAAK,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,QAAQ,GAAG,GAAG,WAAW,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7F,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,qBAAqB,CAC5B,OAAuB,EACvB,uBAAoC,EACpC,UAAuB;IAEvB,IAAI,MAAM,GAAG,IAAI,CAAC;IAClB,QAAQ,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,EAAE;QAChC,IACE,CAAC,MAAM;YACP,WAAW,CAAC,IAAI,KAAK,YAAY;YACjC,CAAC,QAAQ,CAAC,WAAW,CAAC,EACtB,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,GAAG,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9D,IAAI,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1E,MAAM,GAAG,KAAK,CAAC;QACjB,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,kBAAkB,CACzB,QAAmB,EACnB,YAAsC,EACtC,QAAyB;IAEzB,MAAM,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IACxC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,aAAa,CAAC,GAAG,CACf,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAChE,CAAC;QACF,aAAa,CAAC,GAAG,CACf,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CACpE,CAAC;QACF,qBAAqB,CAAC,aAAa,EAAE,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;IAC5E,CAAC;IACD,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,aAAa,CAAC,GAAG,CACf,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAChE,CAAC;IACJ,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,qBAAqB,CAC5B,OAAuB,EACvB,eAAoC;IAEpC,MAAM,QAAQ,GAAoB,EAAE,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,EAAE;QAChC,MAAM,OAAO,GAAG,eAAe,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;QAC9D,IAAI,OAAO,KAAK,KAAK,CAAC,EAAE,CAAC;YACvB,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACzB,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,eAAe,CACtB,WAAwB,EACxB,eAAoC;IAEpC,IAAI,WAAW,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QAC5C,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,WAAW,CAAC;IACzC,IACE,MAAM,CAAC,IAAI,KAAK,YAAY;QAC5B,CAAC,QAAQ,CAAC,MAAM,CAAC;QACjB,QAAQ,CAAC,IAAI,KAAK,YAAY;QAC9B,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EACjC,CAAC;QACD,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,YAAY,GAAG,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtD,OAAO,YAAY,KAAK,KAAK,CAAC;QAC5B,CAAC,CAAC,KAAK,CAAC;QACR,CAAC,CAAC,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;AACvD,CAAC;AAED,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,CAAC","sourcesContent":["import type * as ESTree from \"estree\";\n\nimport type { Binding, Declaration, MemberRewrite } from \"./types\";\n\nimport { hasRange } from \"./match-helpers\";\nimport { walkNode } from \"./match-walk\";\n\n/**\n * Adds declaration identifier range to the allowed set.\n * @param allowedRanges Allowed range set.\n * @param declaration Declaration to include.\n * @example\n * ```typescript\n * const allowed = new Set<string>();\n * addDeclarationIdRange(allowed, void 0);\n * ```\n */\nfunction addDeclarationIdRange(\n  allowedRanges: Set<string>,\n  declaration: Declaration | undefined,\n): void {\n  if (declaration !== void 0) {\n    const rangeKey = `${declaration.declarationIdRange[0]}:${declaration.declarationIdRange[1]}`;\n    allowedRanges.add(rangeKey);\n  }\n}\n\n/**\n * Returns false if a binding local is used outside allowed rewrite sites.\n * @param program Program node containing mock usage.\n * @param allowedIdentifierRanges Identifier ranges that are safe to rewrite.\n * @param localNames Local names tracked by the matcher.\n * @returns True when all local usages are safe.\n * @example\n * ```typescript\n * const safe = areLocalsSafeToInline({ body: [], sourceType: \"module\", type: \"Program\" } as never, new Set(), new Set());\n * void safe;\n * ```\n */\nfunction areLocalsSafeToInline(\n  program: ESTree.Program,\n  allowedIdentifierRanges: Set<string>,\n  localNames: Set<string>,\n): boolean {\n  let isSafe = true;\n  walkNode(program, (currentNode) => {\n    if (\n      !isSafe ||\n      currentNode.type !== \"Identifier\" ||\n      !hasRange(currentNode)\n    ) {\n      return;\n    }\n\n    const key = `${currentNode.range[0]}:${currentNode.range[1]}`;\n    if (localNames.has(currentNode.name) && !allowedIdentifierRanges.has(key)) {\n      isSafe = false;\n    }\n  });\n\n  return isSafe;\n}\n\n/**\n * Builds a set of allowed identifier ranges for safe-inline validation.\n * @param bindings Bindings list.\n * @param declarations Declarations map.\n * @param rewrites Member rewrites.\n * @returns Allowed identifier range keys.\n * @example\n * ```typescript\n * const ranges = buildAllowedRanges([], new Map(), []);\n * void ranges;\n * ```\n */\nfunction buildAllowedRanges(\n  bindings: Binding[],\n  declarations: Map<string, Declaration>,\n  rewrites: MemberRewrite[],\n): Set<string> {\n  const allowedRanges = new Set<string>();\n  for (const binding of bindings) {\n    allowedRanges.add(\n      `${binding.propertyKeyRange[0]}:${binding.propertyKeyRange[1]}`,\n    );\n    allowedRanges.add(\n      `${binding.propertyValueRange[0]}:${binding.propertyValueRange[1]}`,\n    );\n    addDeclarationIdRange(allowedRanges, declarations.get(binding.localName));\n  }\n  for (const rewrite of rewrites) {\n    allowedRanges.add(\n      `${rewrite.localObjectRange[0]}:${rewrite.localObjectRange[1]}`,\n    );\n  }\n\n  return allowedRanges;\n}\n\n/**\n * Collects member-expression object rewrites for `.mock*` calls.\n * @param program Program node.\n * @param localToExported Local to exported name map.\n * @returns Collected member rewrites.\n * @example\n * ```typescript\n * const rewrites = collectMemberRewrites({ body: [], sourceType: \"module\", type: \"Program\" } as never, new Map());\n * void rewrites;\n * ```\n */\nfunction collectMemberRewrites(\n  program: ESTree.Program,\n  localToExported: Map<string, string>,\n): MemberRewrite[] {\n  const rewrites: MemberRewrite[] = [];\n  walkNode(program, (currentNode) => {\n    const rewrite = toMemberRewrite(currentNode, localToExported);\n    if (rewrite !== void 0) {\n      rewrites.push(rewrite);\n    }\n  });\n\n  return rewrites;\n}\n\n/**\n * Converts a node into a member rewrite when supported.\n * @param currentNode Candidate node.\n * @param localToExported Local to exported name map.\n * @returns Member rewrite when node is supported.\n * @example\n * ```typescript\n * const rewrite = toMemberRewrite({ type: \"Identifier\", name: \"x\" } as never, new Map());\n * void rewrite;\n * ```\n */\nfunction toMemberRewrite(\n  currentNode: ESTree.Node,\n  localToExported: Map<string, string>,\n): MemberRewrite | undefined {\n  if (currentNode.type !== \"MemberExpression\") {\n    return void 0;\n  }\n\n  const { object, property } = currentNode;\n  if (\n    object.type !== \"Identifier\" ||\n    !hasRange(object) ||\n    property.type !== \"Identifier\" ||\n    !property.name.startsWith(\"mock\")\n  ) {\n    return void 0;\n  }\n\n  const exportedName = localToExported.get(object.name);\n  return exportedName === void 0\n    ? void 0\n    : { exportedName, localObjectRange: object.range };\n}\n\nexport { areLocalsSafeToInline, buildAllowedRanges, collectMemberRewrites };\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-walk.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match-walk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAqDtC;;;;;;;;GAQG;AACH,iBAAS,QAAQ,CACf,IAAI,EAAE,MAAM,CAAC,IAAI,EACjB,OAAO,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,KAAK,IAAI,GAC1C,IAAI,CAKN;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

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

@@ -0,0 +1,62 @@
+/**
+ * Returns child nodes for a given AST node.
+ * @param node Source node.
+ * @returns Flattened list of child nodes.
+ * @example
+ * ```typescript
+ * const childNodes = getChildNodes({ type: "Program", body: [], sourceType: "module" } as never);
+ * void childNodes;
+ * ```
+ */
+function getChildNodes(node) {
+    const values = Object.entries(node)
+        .filter(([key]) => key !== "parent")
+        .map(([, value]) => value);
+    return values.flatMap((value) => toNodeList(value));
+}
+/**
+ * Checks whether a value is an ESTree node.
+ * @param value Arbitrary value from node property iteration.
+ * @returns True when the value has node-like shape.
+ * @example
+ * ```typescript
+ * const ok = isNode({ type: "Identifier", name: "x" });
+ * void ok;
+ * ```
+ */
+function isNode(value) {
+    return typeof value === "object" && value !== null && "type" in value;
+}
+/**
+ * Converts an unknown value into a list of AST nodes.
+ * @param value Arbitrary value from the AST object graph.
+ * @returns Node list extracted from arrays or single values.
+ * @example
+ * ```typescript
+ * const list = toNodeList([{ type: "Identifier", name: "x" }] as never);
+ * void list;
+ * ```
+ */
+function toNodeList(value) {
+    if (Array.isArray(value)) {
+        return value.filter((nodeValue) => isNode(nodeValue));
+    }
+    return isNode(value) ? [value] : [];
+}
+/**
+ * Visits a node and all nested child nodes.
+ * @param node Root node to visit.
+ * @param visitor Callback run for each visited node.
+ * @example
+ * ```typescript
+ * walkNode({ type: "Program", body: [], sourceType: "module" } as never, () => {});
+ * ```
+ */
+function walkNode(node, visitor) {
+    visitor(node);
+    for (const childNode of getChildNodes(node)) {
+        walkNode(childNode, visitor);
+    }
+}
+export { walkNode };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+import type { Rule } from "eslint";
+import type { RuleMatch } from "./types.js";
+/**
+ * Collects the first applicable rule match from the file.
+ * @param context Rule context.
+ * @returns Collected match when pattern is found.
+ * @example
+ * ```typescript
+ * const match = collectMatch({ sourceCode: { ast: { body: [], sourceType: "module", type: "Program" }, text: "" } } as never);
+ * void match;
+ * ```
+ */
+declare function collectMatch(context: Rule.RuleContext): RuleMatch | undefined;
+/**
+ * Collects every applicable rule match from the file.
+ * @param context Rule context.
+ * @returns Collected matches when patterns are found.
+ * @example
+ * ```typescript
+ * const matches = collectMatches({ sourceCode: { ast: { body: [], sourceType: "module", type: "Program" }, text: "" } } as never);
+ * void matches;
+ * ```
+ */
+declare function collectMatches(context: Rule.RuleContext): RuleMatch[];
+export { collectMatch, collectMatches };
+//# sourceMappingURL=match.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAwFzC;;;;;;;;;GASG;AACH,iBAAS,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,GAAG,SAAS,GAAG,SAAS,CAEtE;AAED;;;;;;;;;GASG;AACH,iBAAS,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,GAAG,SAAS,EAAE,CAM9D;AAmKD,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC"}