@codeperfect/eslint-plugin 1.0.0

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

@@ -0,0 +1,119 @@
+import { hasRange } from "./match-helpers";
+import { walkNode } from "./match-walk";
+/**
+ * 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/testing/prefer-vi-mocked-import/match-rewrites.ts"],"names":[],"mappings":"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","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/testing/prefer-vi-mocked-import/match-walk.d.ts

@@ -0,0 +1,13 @@
+import type * as ESTree from "estree";
+/**
+ * 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, () => {});
+ * ```
+ */
+declare function walkNode(node: ESTree.Node, visitor: (currentNode: ESTree.Node) => void): void;
+export { walkNode };
+//# sourceMappingURL=match-walk.d.ts.map

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

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

@@ -0,0 +1,15 @@
+import type { Rule } from "eslint";
+import type { RuleMatch } from "./types";
+/**
+ * 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;
+export { collectMatch };
+//# sourceMappingURL=match.d.ts.map

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

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

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

@@ -0,0 +1,193 @@
+import { collectBindings } from "./match-bindings";
+import { collectDeclarations } from "./match-declarations";
+import { getFactoryReturnObject, getModuleSpecifier, getNewline, hasRange, } from "./match-helpers";
+import { resolveImportPlan } from "./match-imports";
+import { areLocalsSafeToInline, buildAllowedRanges, collectMemberRewrites, } from "./match-rewrites";
+/**
+ * Builds a full rule match from seed data.
+ * @param context Rule context.
+ * @param program Program node.
+ * @param seed Seed data.
+ * @returns Rule match when safe.
+ * @example
+ * ```typescript
+ * const match = buildMatch({ sourceCode: { text: "" } } as never, { body: [], sourceType: "module", type: "Program" } as never, { factoryObject: { properties: [], type: "ObjectExpression" }, mockStatement: { expression: { arguments: [], type: "CallExpression" }, type: "ExpressionStatement" }, moduleSpecifier: "./x", specifierExpression: { range: [0, 1], type: "Literal", value: "./x" } as never });
+ * void match;
+ * ```
+ */
+function buildMatch(context, program, seed) {
+    const declarations = collectDeclarations(program, context.sourceCode);
+    const bindings = collectBindings(seed.factoryObject, declarations);
+    if (bindings.length === 0) {
+        return void 0;
+    }
+    const memberRewrites = collectMemberRewrites(program, toLocalMap(bindings));
+    const localNames = new Set(bindings.map((binding) => binding.localName));
+    const allowedRanges = buildAllowedRanges(bindings, declarations, memberRewrites);
+    if (!areLocalsSafeToInline(program, allowedRanges, localNames)) {
+        return void 0;
+    }
+    return {
+        bindings,
+        declarations,
+        importPlan: resolveImportPlan(program, seed.moduleSpecifier, getImportNames(bindings)),
+        memberRewrites,
+        mockSpecifierIsImportExpression: seed.specifierExpression.type === "ImportExpression",
+        mockSpecifierRange: seed.specifierExpression.range,
+        moduleSpecifier: seed.moduleSpecifier,
+        newline: getNewline(context.sourceCode.text),
+        node: seed.mockStatement,
+        sourceText: context.sourceCode.text,
+    };
+}
+/**
+ * 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;
+ * ```
+ */
+function collectMatch(context) {
+    const program = context.sourceCode.ast;
+    const seed = collectSeed(program);
+    return seed === void 0 ? void 0 : buildMatch(context, program, seed);
+}
+/**
+ * Collects seed data needed to build a full match.
+ * @param program Program node.
+ * @returns Match seed.
+ * @example
+ * ```typescript
+ * const seed = collectSeed({ body: [], sourceType: "module", type: "Program" } as never);
+ * void seed;
+ * ```
+ */
+function collectSeed(program) {
+    const mockStatement = findMockStatement(program);
+    if (mockStatement === void 0) {
+        return void 0;
+    }
+    const { expression } = mockStatement;
+    if (expression.type !== "CallExpression") {
+        return void 0;
+    }
+    const callArguments = getMockCallArguments(expression);
+    if (callArguments === void 0) {
+        return void 0;
+    }
+    return createSeed(mockStatement, callArguments[0], callArguments[1]);
+}
+/**
+ * Creates seed data from validated call arguments.
+ * @param mockStatement Matched `vi.mock` statement.
+ * @param specifierExpression First argument expression.
+ * @param factoryExpression Factory callback expression.
+ * @returns Match seed when arguments are supported.
+ * @example
+ * ```typescript
+ * const seed = createSeed({ expression: { arguments: [], type: "CallExpression" }, type: "ExpressionStatement" } as never, { type: "Literal", value: "./x" } as never, { body: { properties: [], type: "ObjectExpression" }, type: "ArrowFunctionExpression" } as never);
+ * void seed;
+ * ```
+ */
+function createSeed(mockStatement, specifierExpression, factoryExpression) {
+    if (!hasRange(specifierExpression)) {
+        return void 0;
+    }
+    const moduleSpecifier = getModuleSpecifier(specifierExpression);
+    const factoryObject = getFactoryReturnObject(factoryExpression);
+    return moduleSpecifier === void 0 || factoryObject === void 0
+        ? void 0
+        : { factoryObject, mockStatement, moduleSpecifier, specifierExpression };
+}
+/**
+ * Returns the first top-level `vi.mock` or `vi.doMock` statement.
+ * @param program Program node.
+ * @returns Matching expression statement.
+ * @example
+ * ```typescript
+ * const statement = findMockStatement({ body: [], sourceType: "module", type: "Program" } as never);
+ * void statement;
+ * ```
+ */
+function findMockStatement(program) {
+    return program.body.find((statement) => isMockExpressionStatement(statement));
+}
+/**
+ * Returns sorted unique import names from bindings.
+ * @param bindings Bindings list.
+ * @returns Sorted import names.
+ * @example
+ * ```typescript
+ * const names = getImportNames([]);
+ * void names;
+ * ```
+ */
+function getImportNames(bindings) {
+    return [
+        ...new Set(bindings.map((binding) => binding.exportedName)),
+    ].toSorted();
+}
+/**
+ * Returns mock call arguments when both arguments are supported expressions.
+ * @param expression Call expression node.
+ * @returns First and second call arguments.
+ * @example
+ * ```typescript
+ * const args = getMockCallArguments({ arguments: [], type: "CallExpression" } as never);
+ * void args;
+ * ```
+ */
+function getMockCallArguments(expression) {
+    const [firstArgument, secondArgument] = expression.arguments;
+    if (firstArgument === void 0 || secondArgument === void 0) {
+        return void 0;
+    }
+    if (firstArgument.type === "SpreadElement" ||
+        secondArgument.type === "SpreadElement") {
+        return void 0;
+    }
+    return [firstArgument, secondArgument];
+}
+/**
+ * Checks whether a statement is a supported mock expression statement.
+ * @param statement Candidate statement.
+ * @returns True when statement is a supported mock call.
+ * @example
+ * ```typescript
+ * const ok = isMockExpressionStatement({ type: "EmptyStatement" } as never);
+ * void ok;
+ * ```
+ */
+function isMockExpressionStatement(statement) {
+    if (statement.type !== "ExpressionStatement") {
+        return false;
+    }
+    const { expression } = statement;
+    if (expression.type !== "CallExpression" ||
+        expression.callee.type !== "MemberExpression") {
+        return false;
+    }
+    const { object, property } = expression.callee;
+    return (object.type === "Identifier" &&
+        object.name === "vi" &&
+        property.type === "Identifier" &&
+        (property.name === "mock" || property.name === "doMock"));
+}
+/**
+ * Creates local-to-exported mapping from bindings.
+ * @param bindings Bindings list.
+ * @returns Mapping used for rewrite lookup.
+ * @example
+ * ```typescript
+ * const map = toLocalMap([]);
+ * void map;
+ * ```
+ */
+function toLocalMap(bindings) {
+    return new Map(bindings.map((binding) => [binding.localName, binding.exportedName]));
+}
+export { collectMatch };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"match.js","sourceRoot":"","sources":["../../../src/testing/prefer-vi-mocked-import/match.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport type { RuleMatch } from \"./types\";\n\nimport { collectBindings } from \"./match-bindings\";\nimport { collectDeclarations } from \"./match-declarations\";\nimport {\n  getFactoryReturnObject,\n  getModuleSpecifier,\n  getNewline,\n  hasRange,\n} from \"./match-helpers\";\nimport { resolveImportPlan } from \"./match-imports\";\nimport {\n  areLocalsSafeToInline,\n  buildAllowedRanges,\n  collectMemberRewrites,\n} from \"./match-rewrites\";\n\n/** Type definition for rule data. */\ninterface MatchSeed {\n  /** Returned object expression from the mock factory. */\n  factoryObject: ESTree.ObjectExpression;\n\n  /** Expression statement containing `vi.mock` or `vi.doMock`. */\n  mockStatement: ESTree.ExpressionStatement;\n\n  /** Module path string extracted from the first mock argument. */\n  moduleSpecifier: string;\n\n  /** Original first argument node, including `range`, for fixer use. */\n  specifierExpression: ESTree.Expression & {\n    /** Source range for the mock specifier expression. */\n    range: [number, number];\n  };\n}\n\n/**\n * Builds a full rule match from seed data.\n * @param context Rule context.\n * @param program Program node.\n * @param seed Seed data.\n * @returns Rule match when safe.\n * @example\n * ```typescript\n * const match = buildMatch({ sourceCode: { text: \"\" } } as never, { body: [], sourceType: \"module\", type: \"Program\" } as never, { factoryObject: { properties: [], type: \"ObjectExpression\" }, mockStatement: { expression: { arguments: [], type: \"CallExpression\" }, type: \"ExpressionStatement\" }, moduleSpecifier: \"./x\", specifierExpression: { range: [0, 1], type: \"Literal\", value: \"./x\" } as never });\n * void match;\n * ```\n */\nfunction buildMatch(\n  context: Rule.RuleContext,\n  program: ESTree.Program,\n  seed: MatchSeed,\n): RuleMatch | undefined {\n  const declarations = collectDeclarations(program, context.sourceCode);\n  const bindings = collectBindings(seed.factoryObject, declarations);\n  if (bindings.length === 0) {\n    return void 0;\n  }\n\n  const memberRewrites = collectMemberRewrites(program, toLocalMap(bindings));\n  const localNames = new Set(bindings.map((binding) => binding.localName));\n  const allowedRanges = buildAllowedRanges(\n    bindings,\n    declarations,\n    memberRewrites,\n  );\n  if (!areLocalsSafeToInline(program, allowedRanges, localNames)) {\n    return void 0;\n  }\n\n  return {\n    bindings,\n    declarations,\n    importPlan: resolveImportPlan(\n      program,\n      seed.moduleSpecifier,\n      getImportNames(bindings),\n    ),\n    memberRewrites,\n    mockSpecifierIsImportExpression:\n      seed.specifierExpression.type === \"ImportExpression\",\n    mockSpecifierRange: seed.specifierExpression.range,\n    moduleSpecifier: seed.moduleSpecifier,\n    newline: getNewline(context.sourceCode.text),\n    node: seed.mockStatement as unknown as Rule.Node,\n    sourceText: context.sourceCode.text,\n  };\n}\n\n/**\n * Collects the first applicable rule match from the file.\n * @param context Rule context.\n * @returns Collected match when pattern is found.\n * @example\n * ```typescript\n * const match = collectMatch({ sourceCode: { ast: { body: [], sourceType: \"module\", type: \"Program\" }, text: \"\" } } as never);\n * void match;\n * ```\n */\nfunction collectMatch(context: Rule.RuleContext): RuleMatch | undefined {\n  const program = context.sourceCode.ast as ESTree.Program;\n  const seed = collectSeed(program);\n  return seed === void 0 ? void 0 : buildMatch(context, program, seed);\n}\n\n/**\n * Collects seed data needed to build a full match.\n * @param program Program node.\n * @returns Match seed.\n * @example\n * ```typescript\n * const seed = collectSeed({ body: [], sourceType: \"module\", type: \"Program\" } as never);\n * void seed;\n * ```\n */\nfunction collectSeed(program: ESTree.Program): MatchSeed | undefined {\n  const mockStatement = findMockStatement(program);\n  if (mockStatement === void 0) {\n    return void 0;\n  }\n\n  const { expression } = mockStatement;\n  if (expression.type !== \"CallExpression\") {\n    return void 0;\n  }\n\n  const callArguments = getMockCallArguments(expression);\n  if (callArguments === void 0) {\n    return void 0;\n  }\n\n  return createSeed(mockStatement, callArguments[0], callArguments[1]);\n}\n\n/**\n * Creates seed data from validated call arguments.\n * @param mockStatement Matched `vi.mock` statement.\n * @param specifierExpression First argument expression.\n * @param factoryExpression Factory callback expression.\n * @returns Match seed when arguments are supported.\n * @example\n * ```typescript\n * const seed = createSeed({ expression: { arguments: [], type: \"CallExpression\" }, type: \"ExpressionStatement\" } as never, { type: \"Literal\", value: \"./x\" } as never, { body: { properties: [], type: \"ObjectExpression\" }, type: \"ArrowFunctionExpression\" } as never);\n * void seed;\n * ```\n */\nfunction createSeed(\n  mockStatement: ESTree.ExpressionStatement,\n  specifierExpression: ESTree.Expression,\n  factoryExpression: ESTree.Expression,\n): MatchSeed | undefined {\n  if (!hasRange(specifierExpression)) {\n    return void 0;\n  }\n\n  const moduleSpecifier = getModuleSpecifier(specifierExpression);\n  const factoryObject = getFactoryReturnObject(factoryExpression);\n  return moduleSpecifier === void 0 || factoryObject === void 0\n    ? void 0\n    : { factoryObject, mockStatement, moduleSpecifier, specifierExpression };\n}\n\n/**\n * Returns the first top-level `vi.mock` or `vi.doMock` statement.\n * @param program Program node.\n * @returns Matching expression statement.\n * @example\n * ```typescript\n * const statement = findMockStatement({ body: [], sourceType: \"module\", type: \"Program\" } as never);\n * void statement;\n * ```\n */\nfunction findMockStatement(\n  program: ESTree.Program,\n): ESTree.ExpressionStatement | undefined {\n  return program.body.find(\n    (statement): statement is ESTree.ExpressionStatement =>\n      isMockExpressionStatement(statement),\n  );\n}\n\n/**\n * Returns sorted unique import names from bindings.\n * @param bindings Bindings list.\n * @returns Sorted import names.\n * @example\n * ```typescript\n * const names = getImportNames([]);\n * void names;\n * ```\n */\nfunction getImportNames(bindings: RuleMatch[\"bindings\"]): string[] {\n  return [\n    ...new Set(bindings.map((binding) => binding.exportedName)),\n  ].toSorted();\n}\n\n/**\n * Returns mock call arguments when both arguments are supported expressions.\n * @param expression Call expression node.\n * @returns First and second call arguments.\n * @example\n * ```typescript\n * const args = getMockCallArguments({ arguments: [], type: \"CallExpression\" } as never);\n * void args;\n * ```\n */\nfunction getMockCallArguments(\n  expression: ESTree.CallExpression,\n): [ESTree.Expression, ESTree.Expression] | undefined {\n  const [firstArgument, secondArgument] = expression.arguments;\n  if (firstArgument === void 0 || secondArgument === void 0) {\n    return void 0;\n  }\n  if (\n    firstArgument.type === \"SpreadElement\" ||\n    secondArgument.type === \"SpreadElement\"\n  ) {\n    return void 0;\n  }\n\n  return [firstArgument, secondArgument];\n}\n\n/**\n * Checks whether a statement is a supported mock expression statement.\n * @param statement Candidate statement.\n * @returns True when statement is a supported mock call.\n * @example\n * ```typescript\n * const ok = isMockExpressionStatement({ type: \"EmptyStatement\" } as never);\n * void ok;\n * ```\n */\nfunction isMockExpressionStatement(\n  statement: ESTree.Program[\"body\"][number],\n): boolean {\n  if (statement.type !== \"ExpressionStatement\") {\n    return false;\n  }\n\n  const { expression } = statement;\n  if (\n    expression.type !== \"CallExpression\" ||\n    expression.callee.type !== \"MemberExpression\"\n  ) {\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 === \"mock\" || property.name === \"doMock\")\n  );\n}\n\n/**\n * Creates local-to-exported mapping from bindings.\n * @param bindings Bindings list.\n * @returns Mapping used for rewrite lookup.\n * @example\n * ```typescript\n * const map = toLocalMap([]);\n * void map;\n * ```\n */\nfunction toLocalMap(bindings: RuleMatch[\"bindings\"]): Map<string, string> {\n  return new Map(\n    bindings.map(\n      (binding) => [binding.localName, binding.exportedName] as const,\n    ),\n  );\n}\n\nexport { collectMatch };\n"]}

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

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** Enforce inline `vi.fn()` mocks inside `vi.mock`/`vi.doMock` factories. */
+declare const preferViMockedImportRule: Rule.RuleModule;
+export { preferViMockedImportRule };
+//# sourceMappingURL=rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/testing/prefer-vi-mocked-import/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAMnC,6EAA6E;AAC7E,QAAA,MAAM,wBAAwB,EAAE,IAAI,CAAC,UA+BpC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/testing/prefer-vi-mocked-import/rule.js

@@ -0,0 +1,32 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { buildFix } from "./fix";
+import { collectMatch } from "./match";
+/** Enforce inline `vi.fn()` mocks inside `vi.mock`/`vi.doMock` factories. */
+const preferViMockedImportRule = {
+    create(context) {
+        return {
+            Program: () => {
+                const match = collectMatch(context);
+                if (match === void 0) {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => buildFix(match, fixer),
+                    messageId: "preferViMockedImport",
+                    node: match.node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("prefer-vi-mocked-import", "Prefer inlining vi.fn mocks in vi.mock/vi.doMock factories and using vi.mocked(...)."),
+        fixable: "code",
+        messages: {
+            preferViMockedImport: "Inline vi.fn mocks in the vi.mock/vi.doMock factory and use vi.mocked(...) for calls.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { preferViMockedImportRule };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,83 @@
+import type { Rule } from "eslint";
+import type { Range } from "./match-helpers";
+/** Type definition for rule data. */
+interface Binding {
+    /** Name of the mocked export (object property key). */
+    exportedName: string;
+    /** Local variable name referenced in the mock factory object. */
+    localName: string;
+    /** Range of the object property key identifier. */
+    propertyKeyRange: Range;
+    /** Full range of the object property to replace. */
+    propertyRange: Range;
+    /** Range of the identifier that references the local variable. */
+    propertyValueRange: Range;
+}
+/** Type definition for rule data. */
+interface Declaration {
+    /** Range of the identifier being declared (e.g. `x` in `const x = ...`). */
+    declarationIdRange: Range;
+    /** Range of the initializer expression (the `vi.fn(...)` call). */
+    initializerRange: Range;
+    /** Local variable name. */
+    localName: string;
+    /** Range of the full statement to remove. */
+    statementRange: Range;
+}
+/** Type definition for rule data. */
+interface ImportInsertPlan {
+    /** Range of the last import statement, when present. */
+    afterRange?: Range;
+}
+/** Type definition for rule data. */
+interface ImportPlan {
+    /** Insert plan when no compatible import exists. */
+    insert?: ImportInsertPlan;
+    /** Module specifier to import from. */
+    moduleSpecifier: string;
+    /** Names that must be imported from the module. */
+    names: string[];
+    /** Update plan when an import can be updated in-place. */
+    update?: ImportUpdatePlan;
+}
+/** Type definition for rule data. */
+interface ImportUpdatePlan {
+    /** Default import local name, when present. */
+    defaultImportName?: string;
+    /** Existing named imports from the module. */
+    existingNamedImports: string[];
+    /** Range of the import statement to replace. */
+    range: Range;
+}
+/** Type definition for rule data. */
+interface MemberRewrite {
+    /** Exported name to use inside `vi.mocked(...)`. */
+    exportedName: string;
+    /** Range of the identifier used as the member-expression object. */
+    localObjectRange: Range;
+}
+/** Type definition for rule data. */
+interface RuleMatch {
+    /** Bindings that can be inlined into the mock factory. */
+    bindings: Binding[];
+    /** Declarations by local name. */
+    declarations: Map<string, Declaration>;
+    /** Import insertion/update plan. */
+    importPlan: ImportPlan;
+    /** Member-expression rewrites for `.mock*` calls. */
+    memberRewrites: MemberRewrite[];
+    /** True when the first argument is already `import("...")`. */
+    mockSpecifierIsImportExpression: boolean;
+    /** Range of the first argument to `vi.mock`/`vi.doMock`. */
+    mockSpecifierRange: Range;
+    /** Module specifier being mocked. */
+    moduleSpecifier: string;
+    /** Preferred newline sequence used by the file. */
+    newline: "\n" | "\r\n";
+    /** Node to use for reporting. */
+    node: Rule.Node;
+    /** Full source text. */
+    sourceText: string;
+}
+export type { Binding, Declaration, ImportPlan, MemberRewrite, RuleMatch };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/testing/prefer-vi-mocked-import/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,qCAAqC;AACrC,UAAU,OAAO;IACf,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAC;IAErB,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAElB,mDAAmD;IACnD,gBAAgB,EAAE,KAAK,CAAC;IAExB,oDAAoD;IACpD,aAAa,EAAE,KAAK,CAAC;IAErB,kEAAkE;IAClE,kBAAkB,EAAE,KAAK,CAAC;CAC3B;AAED,qCAAqC;AACrC,UAAU,WAAW;IACnB,4EAA4E;IAC5E,kBAAkB,EAAE,KAAK,CAAC;IAE1B,mEAAmE;IACnE,gBAAgB,EAAE,KAAK,CAAC;IAExB,2BAA2B;IAC3B,SAAS,EAAE,MAAM,CAAC;IAElB,6CAA6C;IAC7C,cAAc,EAAE,KAAK,CAAC;CACvB;AAED,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,wDAAwD;IACxD,UAAU,CAAC,EAAE,KAAK,CAAC;CACpB;AAED,qCAAqC;AACrC,UAAU,UAAU;IAClB,oDAAoD;IACpD,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAE1B,uCAAuC;IACvC,eAAe,EAAE,MAAM,CAAC;IAExB,mDAAmD;IACnD,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,8CAA8C;IAC9C,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAE/B,gDAAgD;IAChD,KAAK,EAAE,KAAK,CAAC;CACd;AAED,qCAAqC;AACrC,UAAU,aAAa;IACrB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IAErB,oEAAoE;IACpE,gBAAgB,EAAE,KAAK,CAAC;CACzB;AAED,qCAAqC;AACrC,UAAU,SAAS;IACjB,0DAA0D;IAC1D,QAAQ,EAAE,OAAO,EAAE,CAAC;IAEpB,kCAAkC;IAClC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAEvC,oCAAoC;IACpC,UAAU,EAAE,UAAU,CAAC;IAEvB,qDAAqD;IACrD,cAAc,EAAE,aAAa,EAAE,CAAC;IAEhC,+DAA+D;IAC/D,+BAA+B,EAAE,OAAO,CAAC;IAEzC,4DAA4D;IAC5D,kBAAkB,EAAE,KAAK,CAAC;IAE1B,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IAExB,mDAAmD;IACnD,OAAO,EAAE,IAAI,GAAG,MAAM,CAAC;IAEvB,iCAAiC;IACjC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAEhB,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC"}

package/dist/testing/prefer-vi-mocked-import/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVzdGluZy9wcmVmZXItdmktbW9ja2VkLWltcG9ydC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSdWxlIH0gZnJvbSBcImVzbGludFwiO1xuXG5pbXBvcnQgdHlwZSB7IFJhbmdlIH0gZnJvbSBcIi4vbWF0Y2gtaGVscGVyc1wiO1xuXG4vKiogVHlwZSBkZWZpbml0aW9uIGZvciBydWxlIGRhdGEuICovXG5pbnRlcmZhY2UgQmluZGluZyB7XG4gIC8qKiBOYW1lIG9mIHRoZSBtb2NrZWQgZXhwb3J0IChvYmplY3QgcHJvcGVydHkga2V5KS4gKi9cbiAgZXhwb3J0ZWROYW1lOiBzdHJpbmc7XG5cbiAgLyoqIExvY2FsIHZhcmlhYmxlIG5hbWUgcmVmZXJlbmNlZCBpbiB0aGUgbW9jayBmYWN0b3J5IG9iamVjdC4gKi9cbiAgbG9jYWxOYW1lOiBzdHJpbmc7XG5cbiAgLyoqIFJhbmdlIG9mIHRoZSBvYmplY3QgcHJvcGVydHkga2V5IGlkZW50aWZpZXIuICovXG4gIHByb3BlcnR5S2V5UmFuZ2U6IFJhbmdlO1xuXG4gIC8qKiBGdWxsIHJhbmdlIG9mIHRoZSBvYmplY3QgcHJvcGVydHkgdG8gcmVwbGFjZS4gKi9cbiAgcHJvcGVydHlSYW5nZTogUmFuZ2U7XG5cbiAgLyoqIFJhbmdlIG9mIHRoZSBpZGVudGlmaWVyIHRoYXQgcmVmZXJlbmNlcyB0aGUgbG9jYWwgdmFyaWFibGUuICovXG4gIHByb3BlcnR5VmFsdWVSYW5nZTogUmFuZ2U7XG59XG5cbi8qKiBUeXBlIGRlZmluaXRpb24gZm9yIHJ1bGUgZGF0YS4gKi9cbmludGVyZmFjZSBEZWNsYXJhdGlvbiB7XG4gIC8qKiBSYW5nZSBvZiB0aGUgaWRlbnRpZmllciBiZWluZyBkZWNsYXJlZCAoZS5nLiBgeGAgaW4gYGNvbnN0IHggPSAuLi5gKS4gKi9cbiAgZGVjbGFyYXRpb25JZFJhbmdlOiBSYW5nZTtcblxuICAvKiogUmFuZ2Ugb2YgdGhlIGluaXRpYWxpemVyIGV4cHJlc3Npb24gKHRoZSBgdmkuZm4oLi4uKWAgY2FsbCkuICovXG4gIGluaXRpYWxpemVyUmFuZ2U6IFJhbmdlO1xuXG4gIC8qKiBMb2NhbCB2YXJpYWJsZSBuYW1lLiAqL1xuICBsb2NhbE5hbWU6IHN0cmluZztcblxuICAvKiogUmFuZ2Ugb2YgdGhlIGZ1bGwgc3RhdGVtZW50IHRvIHJlbW92ZS4gKi9cbiAgc3RhdGVtZW50UmFuZ2U6IFJhbmdlO1xufVxuXG4vKiogVHlwZSBkZWZpbml0aW9uIGZvciBydWxlIGRhdGEuICovXG5pbnRlcmZhY2UgSW1wb3J0SW5zZXJ0UGxhbiB7XG4gIC8qKiBSYW5nZSBvZiB0aGUgbGFzdCBpbXBvcnQgc3RhdGVtZW50LCB3aGVuIHByZXNlbnQuICovXG4gIGFmdGVyUmFuZ2U/OiBSYW5nZTtcbn1cblxuLyoqIFR5cGUgZGVmaW5pdGlvbiBmb3IgcnVsZSBkYXRhLiAqL1xuaW50ZXJmYWNlIEltcG9ydFBsYW4ge1xuICAvKiogSW5zZXJ0IHBsYW4gd2hlbiBubyBjb21wYXRpYmxlIGltcG9ydCBleGlzdHMuICovXG4gIGluc2VydD86IEltcG9ydEluc2VydFBsYW47XG5cbiAgLyoqIE1vZHVsZSBzcGVjaWZpZXIgdG8gaW1wb3J0IGZyb20uICovXG4gIG1vZHVsZVNwZWNpZmllcjogc3RyaW5nO1xuXG4gIC8qKiBOYW1lcyB0aGF0IG11c3QgYmUgaW1wb3J0ZWQgZnJvbSB0aGUgbW9kdWxlLiAqL1xuICBuYW1lczogc3RyaW5nW107XG5cbiAgLyoqIFVwZGF0ZSBwbGFuIHdoZW4gYW4gaW1wb3J0IGNhbiBiZSB1cGRhdGVkIGluLXBsYWNlLiAqL1xuICB1cGRhdGU/OiBJbXBvcnRVcGRhdGVQbGFuO1xufVxuXG4vKiogVHlwZSBkZWZpbml0aW9uIGZvciBydWxlIGRhdGEuICovXG5pbnRlcmZhY2UgSW1wb3J0VXBkYXRlUGxhbiB7XG4gIC8qKiBEZWZhdWx0IGltcG9ydCBsb2NhbCBuYW1lLCB3aGVuIHByZXNlbnQuICovXG4gIGRlZmF1bHRJbXBvcnROYW1lPzogc3RyaW5nO1xuXG4gIC8qKiBFeGlzdGluZyBuYW1lZCBpbXBvcnRzIGZyb20gdGhlIG1vZHVsZS4gKi9cbiAgZXhpc3RpbmdOYW1lZEltcG9ydHM6IHN0cmluZ1tdO1xuXG4gIC8qKiBSYW5nZSBvZiB0aGUgaW1wb3J0IHN0YXRlbWVudCB0byByZXBsYWNlLiAqL1xuICByYW5nZTogUmFuZ2U7XG59XG5cbi8qKiBUeXBlIGRlZmluaXRpb24gZm9yIHJ1bGUgZGF0YS4gKi9cbmludGVyZmFjZSBNZW1iZXJSZXdyaXRlIHtcbiAgLyoqIEV4cG9ydGVkIG5hbWUgdG8gdXNlIGluc2lkZSBgdmkubW9ja2VkKC4uLilgLiAqL1xuICBleHBvcnRlZE5hbWU6IHN0cmluZztcblxuICAvKiogUmFuZ2Ugb2YgdGhlIGlkZW50aWZpZXIgdXNlZCBhcyB0aGUgbWVtYmVyLWV4cHJlc3Npb24gb2JqZWN0LiAqL1xuICBsb2NhbE9iamVjdFJhbmdlOiBSYW5nZTtcbn1cblxuLyoqIFR5cGUgZGVmaW5pdGlvbiBmb3IgcnVsZSBkYXRhLiAqL1xuaW50ZXJmYWNlIFJ1bGVNYXRjaCB7XG4gIC8qKiBCaW5kaW5ncyB0aGF0IGNhbiBiZSBpbmxpbmVkIGludG8gdGhlIG1vY2sgZmFjdG9yeS4gKi9cbiAgYmluZGluZ3M6IEJpbmRpbmdbXTtcblxuICAvKiogRGVjbGFyYXRpb25zIGJ5IGxvY2FsIG5hbWUuICovXG4gIGRlY2xhcmF0aW9uczogTWFwPHN0cmluZywgRGVjbGFyYXRpb24+O1xuXG4gIC8qKiBJbXBvcnQgaW5zZXJ0aW9uL3VwZGF0ZSBwbGFuLiAqL1xuICBpbXBvcnRQbGFuOiBJbXBvcnRQbGFuO1xuXG4gIC8qKiBNZW1iZXItZXhwcmVzc2lvbiByZXdyaXRlcyBmb3IgYC5tb2NrKmAgY2FsbHMuICovXG4gIG1lbWJlclJld3JpdGVzOiBNZW1iZXJSZXdyaXRlW107XG5cbiAgLyoqIFRydWUgd2hlbiB0aGUgZmlyc3QgYXJndW1lbnQgaXMgYWxyZWFkeSBgaW1wb3J0KFwiLi4uXCIpYC4gKi9cbiAgbW9ja1NwZWNpZmllcklzSW1wb3J0RXhwcmVzc2lvbjogYm9vbGVhbjtcblxuICAvKiogUmFuZ2Ugb2YgdGhlIGZpcnN0IGFyZ3VtZW50IHRvIGB2aS5tb2NrYC9gdmkuZG9Nb2NrYC4gKi9cbiAgbW9ja1NwZWNpZmllclJhbmdlOiBSYW5nZTtcblxuICAvKiogTW9kdWxlIHNwZWNpZmllciBiZWluZyBtb2NrZWQuICovXG4gIG1vZHVsZVNwZWNpZmllcjogc3RyaW5nO1xuXG4gIC8qKiBQcmVmZXJyZWQgbmV3bGluZSBzZXF1ZW5jZSB1c2VkIGJ5IHRoZSBmaWxlLiAqL1xuICBuZXdsaW5lOiBcIlxcblwiIHwgXCJcXHJcXG5cIjtcblxuICAvKiogTm9kZSB0byB1c2UgZm9yIHJlcG9ydGluZy4gKi9cbiAgbm9kZTogUnVsZS5Ob2RlO1xuXG4gIC8qKiBGdWxsIHNvdXJjZSB0ZXh0LiAqL1xuICBzb3VyY2VUZXh0OiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIHsgQmluZGluZywgRGVjbGFyYXRpb24sIEltcG9ydFBsYW4sIE1lbWJlclJld3JpdGUsIFJ1bGVNYXRjaCB9O1xuIl19

package/dist/testing/require-aaa-sections/index.d.ts

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

package/dist/testing/require-aaa-sections/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/require-aaa-sections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/require-aaa-sections/index.js

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

package/dist/testing/require-aaa-sections/rule.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const requireAaaSectionsRule: Rule.RuleModule;
+export { requireAaaSectionsRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/testing/require-aaa-sections/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/testing/require-aaa-sections/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAcnC,QAAA,MAAM,sBAAsB,EAAE,IAAI,CAAC,UA+BlC,CAAC;AAiJF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}