uilint-coverage 0.2.150

package/dist/chunk-MSJUSFNN.js

@@ -0,0 +1,1948 @@
+// src/eslint-rules/require-test-coverage/index.ts
+import { createRule, defineRuleMeta } from "uilint-eslint";
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { dirname as dirname2, join as join2, basename as basename2, relative } from "path";
+import { execSync } from "child_process";
+
+// src/eslint-rules/require-test-coverage/lib/file-categorizer.ts
+import { existsSync, readFileSync } from "fs";
+import { basename } from "path";
+import { parse } from "@typescript-eslint/typescript-estree";
+function categorizeFile(filePath, _projectRoot) {
+  const fileName = basename(filePath);
+  if (filePath.endsWith(".d.ts")) {
+    return {
+      category: "type",
+      weight: 0,
+      reason: "TypeScript declaration file (.d.ts)"
+    };
+  }
+  if (/^use[A-Z]/.test(fileName)) {
+    return {
+      category: "core",
+      weight: 1,
+      reason: "React hook (use* pattern)"
+    };
+  }
+  if (/\.service\.(ts|tsx)$/.test(fileName)) {
+    return {
+      category: "core",
+      weight: 1,
+      reason: "Service file (*.service.ts pattern)"
+    };
+  }
+  if (/\.store\.(ts|tsx)$/.test(fileName)) {
+    return {
+      category: "core",
+      weight: 1,
+      reason: "Store file (*.store.ts pattern)"
+    };
+  }
+  if (/\.api\.(ts|tsx)$/.test(fileName)) {
+    return {
+      category: "core",
+      weight: 1,
+      reason: "API file (*.api.ts pattern)"
+    };
+  }
+  if (!existsSync(filePath)) {
+    return {
+      category: "utility",
+      weight: 0.5,
+      reason: "File not found, defaulting to utility"
+    };
+  }
+  let ast;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    ast = parse(content, {
+      jsx: true,
+      loc: true,
+      range: true
+    });
+  } catch {
+    return {
+      category: "utility",
+      weight: 0.5,
+      reason: "Failed to parse file, defaulting to utility"
+    };
+  }
+  const analysis = analyzeExports(ast);
+  if (analysis.hasOnlyTypeExports) {
+    return {
+      category: "type",
+      weight: 0,
+      reason: "File contains only type/interface exports"
+    };
+  }
+  if (analysis.hasJSX) {
+    return {
+      category: "core",
+      weight: 1,
+      reason: "React component (contains JSX)"
+    };
+  }
+  if (analysis.hasOnlyConstantExports) {
+    return {
+      category: "constant",
+      weight: 0.25,
+      reason: "File contains only constant/enum exports"
+    };
+  }
+  return {
+    category: "utility",
+    weight: 0.5,
+    reason: "General utility file with function exports"
+  };
+}
+function analyzeExports(ast) {
+  let hasFunctionExports = false;
+  let hasConstExports = false;
+  let hasTypeExports = false;
+  let hasJSX = false;
+  function visit(node) {
+    if (node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "JSXText") {
+      hasJSX = true;
+    }
+    if (node.type === "ExportNamedDeclaration") {
+      const decl = node.declaration;
+      if (node.exportKind === "type" || decl?.type === "TSTypeAliasDeclaration" || decl?.type === "TSInterfaceDeclaration") {
+        hasTypeExports = true;
+      } else if (decl?.type === "FunctionDeclaration" || decl?.type === "VariableDeclaration" && decl.declarations.some(
+        (d) => d.init?.type === "ArrowFunctionExpression" || d.init?.type === "FunctionExpression"
+      )) {
+        hasFunctionExports = true;
+      } else if (decl?.type === "VariableDeclaration" || decl?.type === "TSEnumDeclaration") {
+        if (decl.type === "VariableDeclaration") {
+          const hasNonFunctionInit = decl.declarations.some(
+            (d) => d.init && d.init.type !== "ArrowFunctionExpression" && d.init.type !== "FunctionExpression"
+          );
+          if (hasNonFunctionInit) {
+            hasConstExports = true;
+          }
+        } else {
+          hasConstExports = true;
+        }
+      } else if (!decl && node.specifiers.length > 0) {
+        hasFunctionExports = true;
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration") {
+      const decl = node.declaration;
+      if (decl.type === "FunctionDeclaration" || decl.type === "ArrowFunctionExpression" || decl.type === "FunctionExpression") {
+        hasFunctionExports = true;
+      } else if (decl.type === "ClassDeclaration") {
+        hasFunctionExports = true;
+      } else {
+        hasConstExports = true;
+      }
+    }
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && "type" in item) {
+              visit(item);
+            }
+          }
+        } else if ("type" in child) {
+          visit(child);
+        }
+      }
+    }
+  }
+  for (const node of ast.body) {
+    visit(node);
+  }
+  const hasOnlyTypeExports = hasTypeExports && !hasFunctionExports && !hasConstExports;
+  const hasOnlyConstantExports = hasConstExports && !hasFunctionExports && !hasTypeExports;
+  return {
+    hasOnlyTypeExports,
+    hasOnlyConstantExports,
+    hasJSX,
+    hasFunctionExports,
+    hasConstExports,
+    hasTypeExports
+  };
+}
+
+// src/eslint-rules/require-test-coverage/lib/dependency-graph.ts
+import { existsSync as existsSync3, statSync } from "fs";
+
+// src/eslint-rules/require-test-coverage/lib/export-resolver.ts
+import { ResolverFactory } from "oxc-resolver";
+import { parse as parse2 } from "@typescript-eslint/typescript-estree";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { dirname, join } from "path";
+var resolverFactory = null;
+var astCache = /* @__PURE__ */ new Map();
+var resolvedPathCache = /* @__PURE__ */ new Map();
+function getResolverFactory() {
+  if (!resolverFactory) {
+    resolverFactory = new ResolverFactory({
+      extensions: [".tsx", ".ts", ".jsx", ".js"],
+      mainFields: ["module", "main"],
+      conditionNames: ["import", "require", "node", "default"],
+      // Enable TypeScript path resolution
+      tsconfig: {
+        configFile: "tsconfig.json",
+        references: "auto"
+      }
+    });
+  }
+  return resolverFactory;
+}
+function resolveImportPath(importSource, fromFile) {
+  const cacheKey = `${fromFile}::${importSource}`;
+  if (resolvedPathCache.has(cacheKey)) {
+    return resolvedPathCache.get(cacheKey) ?? null;
+  }
+  if (importSource.startsWith("react") || importSource.startsWith("next") || !importSource.startsWith(".") && !importSource.startsWith("@/") && !importSource.startsWith("~/")) {
+    if (importSource.includes("@mui/") || importSource.includes("@chakra-ui/") || importSource.includes("antd") || importSource.includes("@radix-ui/")) {
+      resolvedPathCache.set(cacheKey, null);
+      return null;
+    }
+    resolvedPathCache.set(cacheKey, null);
+    return null;
+  }
+  try {
+    const factory = getResolverFactory();
+    const fromDir = dirname(fromFile);
+    const result = factory.sync(fromDir, importSource);
+    if (result.path) {
+      resolvedPathCache.set(cacheKey, result.path);
+      return result.path;
+    }
+  } catch {
+    const resolved = manualResolve(importSource, fromFile);
+    resolvedPathCache.set(cacheKey, resolved);
+    return resolved;
+  }
+  resolvedPathCache.set(cacheKey, null);
+  return null;
+}
+function manualResolve(importSource, fromFile) {
+  const fromDir = dirname(fromFile);
+  const extensions = [".tsx", ".ts", ".jsx", ".js"];
+  if (importSource.startsWith("@/")) {
+    const projectRoot = findProjectRoot(fromFile);
+    if (projectRoot) {
+      const relativePath = importSource.slice(2);
+      for (const ext of extensions) {
+        const candidate = join(projectRoot, relativePath + ext);
+        if (existsSync2(candidate)) {
+          return candidate;
+        }
+        const indexCandidate = join(projectRoot, relativePath, `index${ext}`);
+        if (existsSync2(indexCandidate)) {
+          return indexCandidate;
+        }
+      }
+    }
+  }
+  if (importSource.startsWith(".")) {
+    for (const ext of extensions) {
+      const candidate = join(fromDir, importSource + ext);
+      if (existsSync2(candidate)) {
+        return candidate;
+      }
+      const indexCandidate = join(fromDir, importSource, `index${ext}`);
+      if (existsSync2(indexCandidate)) {
+        return indexCandidate;
+      }
+    }
+  }
+  return null;
+}
+function findProjectRoot(fromFile) {
+  let dir = dirname(fromFile);
+  const root = "/";
+  while (dir !== root) {
+    if (existsSync2(join(dir, "tsconfig.json"))) {
+      return dir;
+    }
+    if (existsSync2(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+function parseFile(filePath) {
+  if (astCache.has(filePath)) {
+    return astCache.get(filePath);
+  }
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const ast = parse2(content, {
+      jsx: true,
+      loc: true,
+      range: true
+    });
+    astCache.set(filePath, ast);
+    return ast;
+  } catch {
+    return null;
+  }
+}
+
+// src/eslint-rules/require-test-coverage/lib/dependency-graph.ts
+var dependencyCache = /* @__PURE__ */ new Map();
+function buildDependencyGraph(entryFile, projectRoot) {
+  const cached = dependencyCache.get(entryFile);
+  if (cached) {
+    try {
+      const currentMtime = statSync(entryFile).mtimeMs;
+      if (currentMtime === cached.mtime) {
+        return cached.graph;
+      }
+    } catch {
+    }
+  }
+  const allDependencies = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  collectDependencies(entryFile, projectRoot, allDependencies, visited);
+  const graph = {
+    root: entryFile,
+    allDependencies
+  };
+  try {
+    const mtime = statSync(entryFile).mtimeMs;
+    dependencyCache.set(entryFile, { graph, mtime });
+  } catch {
+  }
+  return graph;
+}
+function collectDependencies(filePath, projectRoot, allDependencies, visited) {
+  if (visited.has(filePath)) {
+    return;
+  }
+  visited.add(filePath);
+  const imports = extractImports(filePath);
+  for (const importSource of imports) {
+    const resolvedPath = resolveImportPath(importSource, filePath);
+    if (!resolvedPath) {
+      continue;
+    }
+    if (resolvedPath.includes("node_modules")) {
+      continue;
+    }
+    if (!resolvedPath.startsWith(projectRoot)) {
+      continue;
+    }
+    if (visited.has(resolvedPath)) {
+      continue;
+    }
+    allDependencies.add(resolvedPath);
+    collectDependencies(resolvedPath, projectRoot, allDependencies, visited);
+  }
+}
+function extractImports(filePath) {
+  if (!existsSync3(filePath)) {
+    return [];
+  }
+  const ast = parseFile(filePath);
+  if (!ast) {
+    return [];
+  }
+  const imports = [];
+  for (const node of ast.body) {
+    if (node.type === "ImportDeclaration" && node.source.value) {
+      imports.push(node.source.value);
+    }
+    if (node.type === "ExportNamedDeclaration" && node.source?.value) {
+      imports.push(node.source.value);
+    }
+    if (node.type === "ExportAllDeclaration" && node.source.value) {
+      imports.push(node.source.value);
+    }
+  }
+  const dynamicImports = extractDynamicImports(ast);
+  imports.push(...dynamicImports);
+  return imports;
+}
+function extractDynamicImports(ast) {
+  const imports = [];
+  function visit(node) {
+    if (node.type === "ImportExpression" && node.source.type === "Literal" && typeof node.source.value === "string") {
+      imports.push(node.source.value);
+    }
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && "type" in item) {
+              visit(item);
+            }
+          }
+        } else if ("type" in child) {
+          visit(child);
+        }
+      }
+    }
+  }
+  for (const node of ast.body) {
+    visit(node);
+  }
+  return imports;
+}
+
+// src/eslint-rules/require-test-coverage/lib/coverage-aggregator.ts
+function aggregateCoverage(componentFile, projectRoot, coverageData) {
+  const graph = buildDependencyGraph(componentFile, projectRoot);
+  const allFiles = /* @__PURE__ */ new Set([componentFile, ...graph.allDependencies]);
+  const filesAnalyzed = [];
+  const uncoveredFiles = [];
+  let lowestCoverageFile = null;
+  let componentCoverageInfo = null;
+  for (const filePath of allFiles) {
+    const coverageInfo = getFileCoverage(filePath, projectRoot, coverageData);
+    filesAnalyzed.push(coverageInfo);
+    if (filePath === componentFile) {
+      componentCoverageInfo = coverageInfo;
+    }
+    if (coverageInfo.percentage === 0 && coverageInfo.statements.total > 0) {
+      uncoveredFiles.push(filePath);
+    }
+    if (coverageInfo.percentage > 0 && coverageInfo.weight > 0 && coverageInfo.statements.total > 0) {
+      if (!lowestCoverageFile || coverageInfo.percentage < lowestCoverageFile.percentage) {
+        lowestCoverageFile = {
+          path: filePath,
+          percentage: coverageInfo.percentage
+        };
+      }
+    }
+  }
+  const aggregateCoverageValue = calculateWeightedCoverage(filesAnalyzed);
+  return {
+    componentFile,
+    componentCoverage: componentCoverageInfo?.percentage ?? 0,
+    aggregateCoverage: aggregateCoverageValue,
+    totalFiles: filesAnalyzed.length,
+    filesAnalyzed,
+    uncoveredFiles,
+    lowestCoverageFile
+  };
+}
+function getFileCoverage(filePath, projectRoot, coverageData) {
+  const categoryResult = categorizeFile(filePath, projectRoot);
+  const fileCoverage = findCoverageForFile(filePath, coverageData, projectRoot);
+  if (!fileCoverage) {
+    return {
+      filePath,
+      category: categoryResult.category,
+      weight: categoryResult.weight,
+      statements: { covered: 0, total: 0 },
+      percentage: 0
+    };
+  }
+  const statementHits = fileCoverage.s;
+  const totalStatements = Object.keys(statementHits).length;
+  const coveredStatements = Object.values(statementHits).filter(
+    (hits) => hits > 0
+  ).length;
+  const percentage = totalStatements > 0 ? coveredStatements / totalStatements * 100 : 0;
+  return {
+    filePath,
+    category: categoryResult.category,
+    weight: categoryResult.weight,
+    statements: { covered: coveredStatements, total: totalStatements },
+    percentage: Math.round(percentage * 100) / 100
+    // Round to 2 decimal places
+  };
+}
+function findCoverageForFile(filePath, coverageData, projectRoot) {
+  if (coverageData[filePath]) {
+    return coverageData[filePath];
+  }
+  const relativePath = filePath.startsWith(projectRoot) ? filePath.slice(projectRoot.length) : filePath;
+  const pathVariants = [
+    relativePath,
+    relativePath.startsWith("/") ? relativePath.slice(1) : `/${relativePath}`,
+    relativePath.startsWith("/") ? relativePath : `/${relativePath}`
+  ];
+  for (const variant of pathVariants) {
+    if (coverageData[variant]) {
+      return coverageData[variant];
+    }
+  }
+  for (const [coveragePath, coverage] of Object.entries(coverageData)) {
+    if (coveragePath.endsWith(relativePath) || coveragePath.endsWith(relativePath.slice(1))) {
+      return coverage;
+    }
+  }
+  return null;
+}
+function calculateWeightedCoverage(files) {
+  let totalWeightedStatements = 0;
+  let totalWeightedCovered = 0;
+  for (const file of files) {
+    if (file.weight === 0) {
+      continue;
+    }
+    if (file.statements.total === 0) {
+      continue;
+    }
+    const weightedTotal = file.statements.total * file.weight;
+    const weightedCovered = file.statements.covered * file.weight;
+    totalWeightedStatements += weightedTotal;
+    totalWeightedCovered += weightedCovered;
+  }
+  if (totalWeightedStatements === 0) {
+    return 0;
+  }
+  const percentage = totalWeightedCovered / totalWeightedStatements * 100;
+  return Math.round(percentage * 100) / 100;
+}
+
+// src/eslint-rules/require-test-coverage/lib/jsx-coverage-analyzer.ts
+function buildDataLoc(filePath, loc) {
+  return `${filePath}:${loc.start.line}:${loc.start.column}`;
+}
+function findStatementsInRange(loc, fileCoverage) {
+  const overlappingStatements = /* @__PURE__ */ new Set();
+  for (const [statementId, statementLoc] of Object.entries(
+    fileCoverage.statementMap
+  )) {
+    const statementStart = statementLoc.start.line;
+    const statementEnd = statementLoc.end.line;
+    const locStart = loc.start.line;
+    const locEnd = loc.end.line;
+    if (statementStart <= locEnd && locStart <= statementEnd) {
+      overlappingStatements.add(statementId);
+    }
+  }
+  return overlappingStatements;
+}
+function calculateCoverageFromStatements(statementIds, fileCoverage) {
+  if (statementIds.size === 0) {
+    return { covered: 0, total: 0, percentage: 0 };
+  }
+  let covered = 0;
+  const total = statementIds.size;
+  for (const statementId of statementIds) {
+    const hitCount = fileCoverage.s[statementId];
+    if (hitCount !== void 0 && hitCount > 0) {
+      covered++;
+    }
+  }
+  const percentage = total > 0 ? Math.round(covered / total * 100) : 0;
+  return { covered, total, percentage };
+}
+function findCoverageForFile2(coverage, filePath) {
+  if (coverage[filePath]) {
+    return coverage[filePath];
+  }
+  const normalizedPath = filePath.replace(/^\/+/, "");
+  const pathVariants = [
+    normalizedPath,
+    `/${normalizedPath}`,
+    filePath
+  ];
+  for (const variant of pathVariants) {
+    if (coverage[variant]) {
+      return coverage[variant];
+    }
+  }
+  for (const [coveragePath, fileCoverage] of Object.entries(coverage)) {
+    const normalizedCoveragePath = coveragePath.replace(/^\/+/, "");
+    if (normalizedCoveragePath.endsWith(normalizedPath) || normalizedPath.endsWith(normalizedCoveragePath)) {
+      return fileCoverage;
+    }
+  }
+  return void 0;
+}
+function isEventHandlerAttribute(attr) {
+  if (attr.type === "JSXSpreadAttribute") {
+    return false;
+  }
+  if (attr.name.type !== "JSXIdentifier") {
+    return false;
+  }
+  const name = attr.name.name;
+  return /^on[A-Z]/.test(name);
+}
+function analyzeJSXElementCoverage(jsxNode, filePath, coverage, ancestors = [], projectRoot) {
+  const loc = jsxNode.loc;
+  const dataLoc = buildDataLoc(filePath, loc);
+  const eventHandlerNames = [];
+  for (const attr of jsxNode.openingElement.attributes) {
+    if (isEventHandlerAttribute(attr) && attr.type === "JSXAttribute") {
+      if (attr.name.type === "JSXIdentifier") {
+        eventHandlerNames.push(attr.name.name);
+      }
+    }
+  }
+  const hasEventHandlers = eventHandlerNames.length > 0;
+  const fileCoverage = findCoverageForFile2(coverage, filePath);
+  if (!fileCoverage) {
+    return {
+      dataLoc,
+      hasEventHandlers,
+      eventHandlerNames,
+      coverage: { covered: 0, total: 0, percentage: 0 },
+      isCovered: false
+    };
+  }
+  const statementIds = findStatementsInRange(loc, fileCoverage);
+  if (hasEventHandlers) {
+    const handlerStatementIds = getHandlerStatements(
+      jsxNode,
+      fileCoverage,
+      ancestors
+    );
+    for (const stmtId of handlerStatementIds) {
+      statementIds.add(stmtId);
+    }
+  }
+  const conditionalAncestor = findConditionalAncestor(jsxNode, ancestors);
+  if (conditionalAncestor) {
+    const conditionalStatementIds = getConditionalStatements(
+      conditionalAncestor,
+      fileCoverage
+    );
+    for (const stmtId of conditionalStatementIds) {
+      statementIds.add(stmtId);
+    }
+  }
+  const localCoverage = calculateCoverageFromStatements(
+    statementIds,
+    fileCoverage
+  );
+  let importCoverage = { covered: 0, total: 0 };
+  if (projectRoot && ancestors.length > 0) {
+    const importPaths = findImportsUsedInJSX(jsxNode, ancestors);
+    if (importPaths.size > 0) {
+      importCoverage = aggregateImportCoverage(
+        importPaths,
+        coverage,
+        projectRoot,
+        filePath
+      );
+    }
+  }
+  const totalCovered = localCoverage.covered + importCoverage.covered;
+  const totalStatements = localCoverage.total + importCoverage.total;
+  const combinedPercentage = totalStatements > 0 ? Math.round(totalCovered / totalStatements * 100) : 0;
+  const coverageStats = {
+    covered: totalCovered,
+    total: totalStatements,
+    percentage: combinedPercentage
+  };
+  return {
+    dataLoc,
+    hasEventHandlers,
+    eventHandlerNames,
+    coverage: coverageStats,
+    isCovered: coverageStats.percentage > 0
+  };
+}
+function extractEventHandlerExpression(attr) {
+  if (!attr.value) {
+    return null;
+  }
+  if (attr.value.type === "Literal") {
+    return null;
+  }
+  if (attr.value.type === "JSXExpressionContainer") {
+    const expression = attr.value.expression;
+    if (expression.type === "JSXEmptyExpression") {
+      return null;
+    }
+    return expression;
+  }
+  return null;
+}
+function findHandlerFunctionDeclaration(identifier, ancestors) {
+  const targetName = identifier.name;
+  for (const ancestor of ancestors) {
+    if (ancestor.type === "FunctionDeclaration" && ancestor.id?.name === targetName) {
+      return ancestor.body;
+    }
+    if (ancestor.type === "VariableDeclaration") {
+      for (const declarator of ancestor.declarations) {
+        if (declarator.id.type === "Identifier" && declarator.id.name === targetName && declarator.init) {
+          if (declarator.init.type === "ArrowFunctionExpression" || declarator.init.type === "FunctionExpression") {
+            return declarator.init.body;
+          }
+        }
+      }
+    }
+    if (ancestor.type === "BlockStatement" || ancestor.type === "Program") {
+      const body = ancestor.type === "Program" ? ancestor.body : ancestor.body;
+      for (const statement of body) {
+        if (statement.type === "FunctionDeclaration" && statement.id?.name === targetName) {
+          return statement.body;
+        }
+        if (statement.type === "VariableDeclaration") {
+          for (const declarator of statement.declarations) {
+            if (declarator.id.type === "Identifier" && declarator.id.name === targetName && declarator.init) {
+              if (declarator.init.type === "ArrowFunctionExpression" || declarator.init.type === "FunctionExpression") {
+                return declarator.init.body;
+              }
+            }
+          }
+        }
+        if (statement.type === "ExportNamedDeclaration" && statement.declaration) {
+          if (statement.declaration.type === "FunctionDeclaration" && statement.declaration.id?.name === targetName) {
+            return statement.declaration.body;
+          }
+          if (statement.declaration.type === "VariableDeclaration") {
+            for (const declarator of statement.declaration.declarations) {
+              if (declarator.id.type === "Identifier" && declarator.id.name === targetName && declarator.init) {
+                if (declarator.init.type === "ArrowFunctionExpression" || declarator.init.type === "FunctionExpression") {
+                  return declarator.init.body;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (ancestor.type === "ArrowFunctionExpression" || ancestor.type === "FunctionExpression" || ancestor.type === "FunctionDeclaration") {
+      const funcBody = ancestor.body;
+      if (funcBody.type === "BlockStatement") {
+        for (const statement of funcBody.body) {
+          if (statement.type === "FunctionDeclaration" && statement.id?.name === targetName) {
+            return statement.body;
+          }
+          if (statement.type === "VariableDeclaration") {
+            for (const declarator of statement.declarations) {
+              if (declarator.id.type === "Identifier" && declarator.id.name === targetName && declarator.init) {
+                if (declarator.init.type === "ArrowFunctionExpression" || declarator.init.type === "FunctionExpression") {
+                  return declarator.init.body;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function getHandlerStatements(jsxNode, fileCoverage, ancestors = []) {
+  const handlerStatements = /* @__PURE__ */ new Set();
+  for (const attr of jsxNode.openingElement.attributes) {
+    if (!isEventHandlerAttribute(attr) || attr.type !== "JSXAttribute") {
+      continue;
+    }
+    const expression = extractEventHandlerExpression(attr);
+    if (!expression) {
+      continue;
+    }
+    if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression") {
+      const body = expression.body;
+      if (body.loc) {
+        const bodyStatements = findStatementsInRange(body.loc, fileCoverage);
+        for (const stmtId of bodyStatements) {
+          handlerStatements.add(stmtId);
+        }
+      }
+      continue;
+    }
+    if (expression.type === "Identifier") {
+      const functionBody = findHandlerFunctionDeclaration(expression, ancestors);
+      if (functionBody && functionBody.loc) {
+        const bodyStatements = findStatementsInRange(functionBody.loc, fileCoverage);
+        for (const stmtId of bodyStatements) {
+          handlerStatements.add(stmtId);
+        }
+      }
+      continue;
+    }
+    if (expression.type === "CallExpression" && expression.loc) {
+      const callStatements = findStatementsInRange(expression.loc, fileCoverage);
+      for (const stmtId of callStatements) {
+        handlerStatements.add(stmtId);
+      }
+      continue;
+    }
+    if (expression.type === "MemberExpression" && expression.loc) {
+      const memberStatements = findStatementsInRange(expression.loc, fileCoverage);
+      for (const stmtId of memberStatements) {
+        handlerStatements.add(stmtId);
+      }
+    }
+  }
+  return handlerStatements;
+}
+function findConditionalAncestor(node, ancestors) {
+  for (const ancestor of ancestors) {
+    if (ancestor.type === "LogicalExpression" && ancestor.operator === "&&") {
+      return ancestor;
+    }
+    if (ancestor.type === "ConditionalExpression") {
+      return ancestor;
+    }
+    if (ancestor.type === "JSXElement" && ancestor !== node) {
+      break;
+    }
+    if (ancestor.type === "ArrowFunctionExpression" || ancestor.type === "FunctionExpression" || ancestor.type === "FunctionDeclaration") {
+      break;
+    }
+  }
+  return null;
+}
+function getConditionalStatements(conditional, fileCoverage) {
+  const conditionStatements = /* @__PURE__ */ new Set();
+  if (conditional.type === "LogicalExpression") {
+    const condition = conditional.left;
+    if (condition.loc) {
+      const statements = findStatementsInRange(condition.loc, fileCoverage);
+      for (const stmtId of statements) {
+        conditionStatements.add(stmtId);
+      }
+    }
+  } else if (conditional.type === "ConditionalExpression") {
+    const condition = conditional.test;
+    if (condition.loc) {
+      const statements = findStatementsInRange(condition.loc, fileCoverage);
+      for (const stmtId of statements) {
+        conditionStatements.add(stmtId);
+      }
+    }
+  }
+  return conditionStatements;
+}
+function collectIdentifiersFromNode(node, identifiers) {
+  switch (node.type) {
+    case "Identifier":
+      identifiers.add(node.name);
+      break;
+    case "JSXIdentifier":
+      identifiers.add(node.name);
+      break;
+    case "JSXExpressionContainer":
+      if (node.expression.type !== "JSXEmptyExpression") {
+        collectIdentifiersFromNode(node.expression, identifiers);
+      }
+      break;
+    case "JSXElement":
+      collectIdentifiersFromNode(node.openingElement, identifiers);
+      for (const child of node.children) {
+        collectIdentifiersFromNode(child, identifiers);
+      }
+      break;
+    case "JSXOpeningElement":
+      collectIdentifiersFromNode(node.name, identifiers);
+      for (const attr of node.attributes) {
+        collectIdentifiersFromNode(attr, identifiers);
+      }
+      break;
+    case "JSXAttribute":
+      if (node.value) {
+        collectIdentifiersFromNode(node.value, identifiers);
+      }
+      break;
+    case "JSXSpreadAttribute":
+      collectIdentifiersFromNode(node.argument, identifiers);
+      break;
+    case "JSXMemberExpression":
+      collectIdentifiersFromNode(node.object, identifiers);
+      break;
+    case "CallExpression":
+      collectIdentifiersFromNode(node.callee, identifiers);
+      for (const arg of node.arguments) {
+        collectIdentifiersFromNode(arg, identifiers);
+      }
+      break;
+    case "MemberExpression":
+      collectIdentifiersFromNode(node.object, identifiers);
+      break;
+    case "ArrowFunctionExpression":
+    case "FunctionExpression":
+      collectIdentifiersFromNode(node.body, identifiers);
+      break;
+    case "BlockStatement":
+      for (const statement of node.body) {
+        collectIdentifiersFromNode(statement, identifiers);
+      }
+      break;
+    case "ExpressionStatement":
+      collectIdentifiersFromNode(node.expression, identifiers);
+      break;
+    case "ReturnStatement":
+      if (node.argument) {
+        collectIdentifiersFromNode(node.argument, identifiers);
+      }
+      break;
+    case "BinaryExpression":
+    case "LogicalExpression":
+      collectIdentifiersFromNode(node.left, identifiers);
+      collectIdentifiersFromNode(node.right, identifiers);
+      break;
+    case "ConditionalExpression":
+      collectIdentifiersFromNode(node.test, identifiers);
+      collectIdentifiersFromNode(node.consequent, identifiers);
+      collectIdentifiersFromNode(node.alternate, identifiers);
+      break;
+    case "UnaryExpression":
+      collectIdentifiersFromNode(node.argument, identifiers);
+      break;
+    case "TemplateLiteral":
+      for (const expr of node.expressions) {
+        collectIdentifiersFromNode(expr, identifiers);
+      }
+      break;
+    case "ArrayExpression":
+      for (const element of node.elements) {
+        if (element) {
+          collectIdentifiersFromNode(element, identifiers);
+        }
+      }
+      break;
+    case "ObjectExpression":
+      for (const prop of node.properties) {
+        collectIdentifiersFromNode(prop, identifiers);
+      }
+      break;
+    case "Property":
+      collectIdentifiersFromNode(node.value, identifiers);
+      break;
+    case "SpreadElement":
+      collectIdentifiersFromNode(node.argument, identifiers);
+      break;
+    case "JSXText":
+    case "JSXFragment":
+    case "Literal":
+      break;
+    default:
+      break;
+  }
+}
+function findImportsUsedInJSX(jsxNode, ancestors) {
+  const importPaths = /* @__PURE__ */ new Set();
+  const usedIdentifiers = /* @__PURE__ */ new Set();
+  collectIdentifiersFromNode(jsxNode, usedIdentifiers);
+  let programNode = null;
+  for (const ancestor of ancestors) {
+    if (ancestor.type === "Program") {
+      programNode = ancestor;
+      break;
+    }
+  }
+  if (!programNode) {
+    return importPaths;
+  }
+  const importedIdentifiers = /* @__PURE__ */ new Map();
+  for (const statement of programNode.body) {
+    if (statement.type === "ImportDeclaration") {
+      const source = statement.source.value;
+      if (typeof source !== "string") {
+        continue;
+      }
+      for (const specifier of statement.specifiers) {
+        switch (specifier.type) {
+          case "ImportDefaultSpecifier":
+            importedIdentifiers.set(specifier.local.name, source);
+            break;
+          case "ImportSpecifier":
+            importedIdentifiers.set(specifier.local.name, source);
+            break;
+          case "ImportNamespaceSpecifier":
+            importedIdentifiers.set(specifier.local.name, source);
+            break;
+        }
+      }
+    }
+  }
+  for (const identifier of usedIdentifiers) {
+    const importSource = importedIdentifiers.get(identifier);
+    if (importSource) {
+      importPaths.add(importSource);
+    }
+  }
+  return importPaths;
+}
+function resolveImportPath2(importPath, currentFilePath, projectRoot) {
+  if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
+    return null;
+  }
+  const lastSlashIndex = currentFilePath.lastIndexOf("/");
+  const currentDir = lastSlashIndex >= 0 ? currentFilePath.slice(0, lastSlashIndex) : projectRoot;
+  let resolvedPath;
+  if (importPath.startsWith("/")) {
+    resolvedPath = projectRoot + importPath;
+  } else {
+    const parts = currentDir.split("/").filter(Boolean);
+    const importParts = importPath.split("/");
+    for (const part of importParts) {
+      if (part === ".") {
+        continue;
+      } else if (part === "..") {
+        parts.pop();
+      } else {
+        parts.push(part);
+      }
+    }
+    resolvedPath = "/" + parts.join("/");
+  }
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+  for (const ext of extensions) {
+    const fullPath = resolvedPath + ext;
+    if (ext === "" && (resolvedPath.endsWith(".ts") || resolvedPath.endsWith(".tsx") || resolvedPath.endsWith(".js") || resolvedPath.endsWith(".jsx"))) {
+      return resolvedPath;
+    }
+    if (ext !== "") {
+      return fullPath;
+    }
+  }
+  return resolvedPath;
+}
+function aggregateImportCoverage(importPaths, coverage, projectRoot, currentFilePath = "") {
+  let totalCovered = 0;
+  let totalStatements = 0;
+  for (const importPath of importPaths) {
+    const resolvedPath = resolveImportPath2(importPath, currentFilePath, projectRoot);
+    if (!resolvedPath) {
+      continue;
+    }
+    const fileCoverage = findCoverageForFile2(coverage, resolvedPath);
+    if (!fileCoverage) {
+      const rawCoverage = findCoverageForFile2(coverage, importPath);
+      if (!rawCoverage) {
+        continue;
+      }
+      const statementCount2 = Object.keys(rawCoverage.s).length;
+      const coveredCount2 = Object.values(rawCoverage.s).filter((hits) => hits > 0).length;
+      totalStatements += statementCount2;
+      totalCovered += coveredCount2;
+      continue;
+    }
+    const statementCount = Object.keys(fileCoverage.s).length;
+    const coveredCount = Object.values(fileCoverage.s).filter((hits) => hits > 0).length;
+    totalStatements += statementCount;
+    totalCovered += coveredCount;
+  }
+  return { covered: totalCovered, total: totalStatements };
+}
+
+// src/eslint-rules/require-test-coverage/lib/chunk-analyzer.ts
+function containsJSX(node, visited = /* @__PURE__ */ new WeakSet()) {
+  if (!node || typeof node !== "object") return false;
+  if (visited.has(node)) return false;
+  visited.add(node);
+  if (node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "JSXText") {
+    return true;
+  }
+  const childKeys = [
+    "body",
+    "declarations",
+    "declaration",
+    "expression",
+    "expressions",
+    "argument",
+    "arguments",
+    "callee",
+    "elements",
+    "properties",
+    "value",
+    "init",
+    "consequent",
+    "alternate",
+    "test",
+    "left",
+    "right",
+    "object",
+    "property",
+    "children",
+    "openingElement",
+    "closingElement"
+  ];
+  for (const key of childKeys) {
+    const child = node[key];
+    if (child && typeof child === "object") {
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && "type" in item) {
+            if (containsJSX(item, visited)) return true;
+          }
+        }
+      } else if ("type" in child) {
+        if (containsJSX(child, visited)) return true;
+      }
+    }
+  }
+  return false;
+}
+function categorizeChunk(name, functionBody, isInStoreFile) {
+  if (/^use[A-Z]/.test(name)) {
+    return { category: "hook", isReactRelated: true };
+  }
+  if (isInStoreFile || /Store$/.test(name)) {
+    return { category: "store", isReactRelated: false };
+  }
+  if (/^handle[A-Z]/.test(name) || /^on[A-Z]/.test(name)) {
+    return { category: "handler", isReactRelated: true };
+  }
+  if (functionBody && containsJSX(functionBody)) {
+    return { category: "component", isReactRelated: true };
+  }
+  return { category: "utility", isReactRelated: false };
+}
+function findFnId(name, loc, fileCoverage) {
+  if (!fileCoverage) return null;
+  for (const [fnId, fnInfo] of Object.entries(fileCoverage.fnMap)) {
+    if (fnInfo.name === name) {
+      return fnId;
+    }
+    if (fnInfo.decl.start.line === loc.start.line || fnInfo.loc.start.line === loc.start.line) {
+      return fnId;
+    }
+  }
+  return null;
+}
+function calculateChunkCoverage(fnId, loc, fileCoverage) {
+  if (!fileCoverage) {
+    return {
+      functionCalled: false,
+      statementsCovered: 0,
+      statementsTotal: 0,
+      percentage: 0
+    };
+  }
+  const functionCalled = fnId !== null && (fileCoverage.f[fnId] ?? 0) > 0;
+  const statementIds = findStatementsInRange(loc, fileCoverage);
+  const stats = calculateCoverageFromStatements(statementIds, fileCoverage);
+  return {
+    functionCalled,
+    statementsCovered: stats.covered,
+    statementsTotal: stats.total,
+    percentage: stats.percentage
+  };
+}
+function getDeclarationLoc(loc) {
+  return {
+    start: loc.start,
+    end: { line: loc.start.line, column: 999 }
+  };
+}
+function collectExportedFunctions(ast) {
+  const exports = [];
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "FunctionDeclaration" && node.declaration.id) {
+      const loc = node.declaration.loc;
+      exports.push({
+        name: node.declaration.id.name,
+        node: node.declaration,
+        loc,
+        declarationLoc: getDeclarationLoc(loc),
+        body: node.declaration.body
+      });
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      for (const decl of node.declaration.declarations) {
+        if (decl.id.type === "Identifier" && decl.init && (decl.init.type === "ArrowFunctionExpression" || decl.init.type === "FunctionExpression")) {
+          const loc = decl.init.loc;
+          const declarationLoc = getDeclarationLoc(decl.loc);
+          exports.push({
+            name: decl.id.name,
+            node: decl.init,
+            loc,
+            declarationLoc,
+            body: decl.init.body
+          });
+        }
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "FunctionDeclaration") {
+      const name = node.declaration.id?.name ?? "default";
+      const loc = node.declaration.loc;
+      exports.push({
+        name,
+        node: node.declaration,
+        loc,
+        declarationLoc: getDeclarationLoc(loc),
+        body: node.declaration.body
+      });
+    }
+    if (node.type === "ExportDefaultDeclaration" && (node.declaration.type === "ArrowFunctionExpression" || node.declaration.type === "FunctionExpression")) {
+      const loc = node.declaration.loc;
+      exports.push({
+        name: "default",
+        node: node.declaration,
+        loc,
+        declarationLoc: getDeclarationLoc(loc),
+        body: node.declaration.body
+      });
+    }
+  }
+  return exports;
+}
+function analyzeChunks(ast, filePath, fileCoverage) {
+  const isInStoreFile = /\.store\.(ts|tsx)$/.test(filePath);
+  const exportedFunctions = collectExportedFunctions(ast);
+  const results = [];
+  for (const exported of exportedFunctions) {
+    const { category, isReactRelated } = categorizeChunk(
+      exported.name,
+      exported.body,
+      isInStoreFile
+    );
+    const fnId = findFnId(exported.name, exported.loc, fileCoverage);
+    const coverage = calculateChunkCoverage(fnId, exported.loc, fileCoverage);
+    results.push({
+      name: exported.name,
+      category,
+      isReactRelated,
+      loc: exported.loc,
+      declarationLoc: exported.declarationLoc,
+      fnId,
+      isExport: true,
+      coverage
+    });
+  }
+  return results;
+}
+function getChunkThreshold(chunk, options) {
+  const strictThreshold = options.chunkThreshold ?? 80;
+  const relaxedThreshold = options.relaxedThreshold ?? 50;
+  if (!options.focusNonReact) {
+    return strictThreshold;
+  }
+  if (chunk.category === "component" || chunk.category === "handler") {
+    return relaxedThreshold;
+  }
+  return strictThreshold;
+}
+
+// src/eslint-rules/require-test-coverage/index.ts
+function simpleGlobMatch(pattern, path) {
+  const normalizedPath = path.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const regexStr = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/{{GLOBSTAR}}/g, ".*");
+  const regex = new RegExp(`^${regexStr}$`);
+  return regex.test(normalizedPath);
+}
+var meta = defineRuleMeta({
+  id: "require-test-coverage",
+  version: "1.0.0",
+  name: "Require Test Coverage",
+  description: "Enforce that source files have adequate test coverage",
+  defaultSeverity: "warn",
+  category: "coverage",
+  icon: "\u{1F9EA}",
+  hint: "Ensures code has tests",
+  defaultEnabled: true,
+  isDirectoryBased: true,
+  plugin: "coverage",
+  eslintImport: "uilint-coverage/eslint-rules/require-test-coverage",
+  npmDependencies: ["@vitest/coverage-v8"],
+  requirements: [
+    {
+      type: "coverage",
+      description: "Requires test coverage data",
+      setupHint: "Run tests with coverage: npm test -- --coverage"
+    }
+  ],
+  defaultOptions: [
+    {
+      coveragePath: "coverage/coverage-final.json",
+      threshold: 80,
+      thresholdsByPattern: [],
+      severity: {
+        noCoverage: "error",
+        belowThreshold: "warn"
+      },
+      testPatterns: [
+        ".test.ts",
+        ".test.tsx",
+        ".spec.ts",
+        ".spec.tsx",
+        "__tests__/"
+      ],
+      ignorePatterns: ["**/*.d.ts", "**/index.ts"],
+      mode: "all",
+      baseBranch: "main"
+    }
+  ],
+  optionSchema: {
+    fields: [
+      {
+        key: "threshold",
+        label: "Coverage threshold",
+        type: "number",
+        defaultValue: 80,
+        description: "Minimum coverage percentage required (0-100)"
+      },
+      {
+        key: "coveragePath",
+        label: "Coverage file path",
+        type: "text",
+        defaultValue: "coverage/coverage-final.json",
+        description: "Path to Istanbul coverage JSON file"
+      },
+      {
+        key: "mode",
+        label: "Mode",
+        type: "select",
+        defaultValue: "all",
+        options: [
+          { value: "all", label: "Check all code" },
+          { value: "changed", label: "Only check changed lines" }
+        ],
+        description: "Whether to check all code or only git-changed lines"
+      },
+      {
+        key: "chunkCoverage",
+        label: "Enable chunk-level coverage",
+        type: "boolean",
+        defaultValue: true,
+        description: "Report coverage for individual functions instead of file level"
+      },
+      {
+        key: "focusNonReact",
+        label: "Focus on non-React code",
+        type: "boolean",
+        defaultValue: false,
+        description: "Apply strict thresholds to utilities/stores/hooks, relaxed to components"
+      },
+      {
+        key: "chunkThreshold",
+        label: "Chunk coverage threshold",
+        type: "number",
+        defaultValue: 80,
+        description: "Minimum coverage for utility/hook/store chunks (0-100)"
+      },
+      {
+        key: "relaxedThreshold",
+        label: "Relaxed threshold for React code",
+        type: "number",
+        defaultValue: 50,
+        description: "Threshold for components/handlers when focusNonReact is enabled"
+      },
+      {
+        key: "minStatements",
+        label: "Minimum statements for coverage",
+        type: "number",
+        defaultValue: 5,
+        description: "Files with fewer statements are exempt from coverage requirements"
+      }
+    ]
+  },
+  docs: `
+## What it does
+
+Enforces that source files have test coverage above a configurable threshold.
+It checks for:
+- Existence of corresponding test files
+- Coverage data in Istanbul JSON format
+- Statement coverage percentage meeting the threshold
+
+## Why it's useful
+
+- **Quality Assurance**: Ensures critical code is tested
+- **Catch Regressions**: Prevents merging untested changes
+- **Configurable**: Different thresholds for different file patterns
+- **Git Integration**: Can focus only on changed lines
+
+## Configuration
+
+\`\`\`js
+// eslint.config.js
+"uilint/require-test-coverage": ["warn", {
+  coveragePath: "coverage/coverage-final.json",
+  threshold: 80,
+  thresholdsByPattern: [
+    { pattern: "**/utils/*.ts", threshold: 90 },
+    { pattern: "**/generated/**", threshold: 0 },
+  ],
+  severity: {
+    noCoverage: "error",
+    belowThreshold: "warn",
+  },
+  testPatterns: [".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx", "__tests__/"],
+  ignorePatterns: ["**/*.d.ts", "**/index.ts"],
+  mode: "all",       // or "changed"
+  baseBranch: "main" // for "changed" mode
+}]
+\`\`\`
+
+## Examples
+
+### Below threshold:
+\`\`\`ts
+// src/api.ts - 40% coverage (threshold: 80%)
+export function fetchData() { ... }  // Warning: Coverage below threshold
+\`\`\`
+`
+});
+var coverageCache = null;
+function clearCoverageCache() {
+  coverageCache = null;
+}
+function findProjectRoot2(startPath) {
+  let current = startPath;
+  let lastPackageJson = null;
+  while (current !== dirname2(current)) {
+    if (existsSync4(join2(current, "package.json"))) {
+      lastPackageJson = current;
+    }
+    if (existsSync4(join2(current, "coverage"))) {
+      return current;
+    }
+    current = dirname2(current);
+  }
+  return lastPackageJson || startPath;
+}
+function loadCoverage(projectRoot, coveragePath) {
+  const fullPath = join2(projectRoot, coveragePath);
+  if (!existsSync4(fullPath)) {
+    return null;
+  }
+  try {
+    const stat = statSync2(fullPath);
+    const mtime = stat.mtimeMs;
+    if (coverageCache && coverageCache.projectRoot === projectRoot && coverageCache.coveragePath === coveragePath && coverageCache.mtime === mtime) {
+      return coverageCache.data;
+    }
+    const content = readFileSync3(fullPath, "utf-8");
+    const data = JSON.parse(content);
+    coverageCache = {
+      projectRoot,
+      coveragePath,
+      mtime,
+      data
+    };
+    return data;
+  } catch {
+    return null;
+  }
+}
+function calculateCoverage(fileCoverage) {
+  const statements = fileCoverage.s;
+  const keys = Object.keys(statements);
+  if (keys.length === 0) {
+    return 100;
+  }
+  const covered = keys.filter((key) => statements[key] > 0).length;
+  return Math.round(covered / keys.length * 100);
+}
+function shouldIgnore(filePath, ignorePatterns) {
+  for (const pattern of ignorePatterns) {
+    if (simpleGlobMatch(pattern, filePath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getThreshold(filePath, globalThreshold, thresholdsByPattern) {
+  for (const { pattern, threshold } of thresholdsByPattern) {
+    if (simpleGlobMatch(pattern, filePath)) {
+      return threshold;
+    }
+  }
+  return globalThreshold;
+}
+function getChangedLines(projectRoot, filePath, baseBranch) {
+  try {
+    const relPath = relative(projectRoot, filePath);
+    const diff = execSync(`git diff ${baseBranch}...HEAD -- "${relPath}"`, {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const changedLines = /* @__PURE__ */ new Set();
+    const lines = diff.split("\n");
+    let currentLine = 0;
+    for (const line of lines) {
+      const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+      if (hunkMatch) {
+        currentLine = parseInt(hunkMatch[1], 10);
+        continue;
+      }
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        changedLines.add(currentLine);
+        currentLine++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+      } else if (!line.startsWith("\\")) {
+        currentLine++;
+      }
+    }
+    return changedLines;
+  } catch {
+    return null;
+  }
+}
+function calculateChangedLinesCoverage(fileCoverage, changedLines) {
+  const statementMap = fileCoverage.statementMap;
+  const statements = fileCoverage.s;
+  let relevantStatements = 0;
+  let coveredStatements = 0;
+  for (const [key, location] of Object.entries(statementMap)) {
+    let isRelevant = false;
+    for (let line = location.start.line; line <= location.end.line; line++) {
+      if (changedLines.has(line)) {
+        isRelevant = true;
+        break;
+      }
+    }
+    if (isRelevant) {
+      relevantStatements++;
+      if (statements[key] > 0) {
+        coveredStatements++;
+      }
+    }
+  }
+  if (relevantStatements === 0) {
+    return 100;
+  }
+  return Math.round(coveredStatements / relevantStatements * 100);
+}
+function findCoverageForFile3(coverage, filePath, projectRoot) {
+  if (coverage[filePath]) {
+    return coverage[filePath];
+  }
+  const relPath = relative(projectRoot, filePath);
+  if (coverage[relPath]) {
+    return coverage[relPath];
+  }
+  const withSlash = "/" + relPath;
+  if (coverage[withSlash]) {
+    return coverage[withSlash];
+  }
+  const srcMatch = relPath.match(/src\/.+$/);
+  if (srcMatch) {
+    const srcPath = "/" + srcMatch[0];
+    if (coverage[srcPath]) {
+      return coverage[srcPath];
+    }
+  }
+  return null;
+}
+var require_test_coverage_default = createRule({
+  name: "require-test-coverage",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce that source files have adequate test coverage"
+    },
+    messages: {
+      noCoverage: "No coverage data found for '{{fileName}}' in coverage report",
+      belowThreshold: "Coverage for '{{fileName}}' is {{coverage}}%, below threshold of {{threshold}}%",
+      noCoverageData: "Coverage data not found at '{{coveragePath}}'. Run tests with coverage first.",
+      belowAggregateThreshold: "Aggregate coverage ({{coverage}}%) is below threshold ({{threshold}}%). Includes {{fileCount}} files. Lowest: {{lowestFile}} ({{lowestCoverage}}%)",
+      jsxBelowThreshold: "<{{tagName}}> element coverage is {{coverage}}%, below threshold of {{threshold}}%",
+      chunkBelowThreshold: "{{category}} '{{name}}' has {{coverage}}% coverage, below {{threshold}}% threshold",
+      untestedFunction: "Function '{{name}}' ({{category}}) is not covered by tests"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          coveragePath: {
+            type: "string",
+            description: "Path to coverage JSON file"
+          },
+          threshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 100,
+            description: "Coverage threshold percentage"
+          },
+          thresholdsByPattern: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                pattern: { type: "string" },
+                threshold: { type: "number", minimum: 0, maximum: 100 }
+              },
+              required: ["pattern", "threshold"],
+              additionalProperties: false
+            },
+            description: "Pattern-specific thresholds"
+          },
+          severity: {
+            type: "object",
+            properties: {
+              noCoverage: { type: "string", enum: ["error", "warn", "off"] },
+              belowThreshold: {
+                type: "string",
+                enum: ["error", "warn", "off"]
+              }
+            },
+            additionalProperties: false
+          },
+          testPatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "Patterns to detect test files"
+          },
+          ignorePatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "Glob patterns for files to ignore"
+          },
+          mode: {
+            type: "string",
+            enum: ["all", "changed"],
+            description: "Check all code or only changed lines"
+          },
+          baseBranch: {
+            type: "string",
+            description: "Base branch for changed mode"
+          },
+          aggregateThreshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 100,
+            description: "Aggregate coverage threshold for components (includes dependencies)"
+          },
+          aggregateSeverity: {
+            type: "string",
+            enum: ["error", "warn", "off"],
+            description: "Severity for aggregate coverage check"
+          },
+          jsxThreshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 100,
+            description: "JSX element coverage threshold percentage (includes event handlers)"
+          },
+          jsxSeverity: {
+            type: "string",
+            enum: ["error", "warn", "off"],
+            description: "Severity for JSX element coverage check"
+          },
+          chunkCoverage: {
+            type: "boolean",
+            description: "Enable chunk-level coverage reporting (replaces file-level)"
+          },
+          chunkThreshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 100,
+            description: "Threshold for strict categories (utility/hook/store)"
+          },
+          focusNonReact: {
+            type: "boolean",
+            description: "Focus on non-React code with relaxed thresholds for components"
+          },
+          relaxedThreshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 100,
+            description: "Threshold for relaxed categories (component/handler)"
+          },
+          chunkSeverity: {
+            type: "string",
+            enum: ["error", "warn", "off"],
+            description: "Severity for chunk coverage check"
+          },
+          minStatements: {
+            type: "number",
+            minimum: 0,
+            description: "Files with fewer statements are exempt from coverage requirements"
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [
+    {
+      coveragePath: "coverage/coverage-final.json",
+      threshold: 80,
+      thresholdsByPattern: [],
+      severity: {
+        noCoverage: "error",
+        belowThreshold: "warn"
+      },
+      testPatterns: [
+        ".test.ts",
+        ".test.tsx",
+        ".spec.ts",
+        ".spec.tsx",
+        "__tests__/"
+      ],
+      ignorePatterns: ["**/*.d.ts", "**/index.ts"],
+      mode: "all",
+      baseBranch: "main",
+      aggregateThreshold: 70,
+      aggregateSeverity: "warn",
+      jsxThreshold: 50,
+      jsxSeverity: "warn",
+      chunkCoverage: true,
+      chunkThreshold: 80,
+      focusNonReact: false,
+      relaxedThreshold: 50,
+      chunkSeverity: "warn",
+      minStatements: 5
+    }
+  ],
+  create(context) {
+    const options = context.options[0] || {};
+    const coveragePath = options.coveragePath ?? "coverage/coverage-final.json";
+    const threshold = options.threshold ?? 80;
+    const thresholdsByPattern = options.thresholdsByPattern ?? [];
+    const severity = {
+      noCoverage: options.severity?.noCoverage ?? "error",
+      belowThreshold: options.severity?.belowThreshold ?? "warn"
+    };
+    const aggregateThreshold = options.aggregateThreshold ?? 70;
+    const aggregateSeverity = options.aggregateSeverity ?? "warn";
+    const testPatterns = options.testPatterns ?? [
+      ".test.ts",
+      ".test.tsx",
+      ".spec.ts",
+      ".spec.tsx",
+      "__tests__/"
+    ];
+    const ignorePatterns = options.ignorePatterns ?? [
+      "**/*.d.ts",
+      "**/index.ts"
+    ];
+    const mode = options.mode ?? "all";
+    const baseBranch = options.baseBranch ?? "main";
+    const jsxThreshold = options.jsxThreshold ?? 50;
+    const jsxSeverity = options.jsxSeverity ?? "warn";
+    const chunkCoverage = options.chunkCoverage ?? true;
+    const chunkThreshold = options.chunkThreshold ?? 80;
+    const focusNonReact = options.focusNonReact ?? false;
+    const relaxedThreshold = options.relaxedThreshold ?? 50;
+    const chunkSeverity = options.chunkSeverity ?? "warn";
+    const minStatements = options.minStatements ?? 5;
+    const filename = context.filename || context.getFilename();
+    const projectRoot = findProjectRoot2(dirname2(filename));
+    const relPath = relative(projectRoot, filename);
+    if (shouldIgnore(relPath, ignorePatterns)) {
+      return {};
+    }
+    if (testPatterns.some(
+      (p) => filename.includes(p.replace("__tests__/", "__tests__"))
+    )) {
+      return {};
+    }
+    let reported = false;
+    const jsxElements = [];
+    return {
+      // Collect JSX elements for element-level coverage analysis
+      JSXElement(node) {
+        const ancestors = context.sourceCode?.getAncestors?.(node) ?? [];
+        jsxElements.push({ node, ancestors });
+      },
+      "Program:exit"(node) {
+        if (reported) return;
+        reported = true;
+        const coverage = loadCoverage(projectRoot, coveragePath);
+        if (!coverage) {
+          if (severity.noCoverage !== "off") {
+            context.report({
+              node,
+              messageId: "noCoverageData",
+              data: {
+                coveragePath
+              }
+            });
+          }
+          return;
+        }
+        const fileCoverage = findCoverageForFile3(
+          coverage,
+          filename,
+          projectRoot
+        );
+        if (!fileCoverage) {
+          return;
+        }
+        const statementCount = Object.keys(fileCoverage.s).length;
+        if (statementCount < minStatements) {
+          return;
+        }
+        let coveragePercent;
+        if (mode === "changed") {
+          const changedLines = getChangedLines(
+            projectRoot,
+            filename,
+            baseBranch
+          );
+          if (changedLines && changedLines.size > 0) {
+            coveragePercent = calculateChangedLinesCoverage(
+              fileCoverage,
+              changedLines
+            );
+          } else {
+            coveragePercent = calculateCoverage(fileCoverage);
+          }
+        } else {
+          coveragePercent = calculateCoverage(fileCoverage);
+        }
+        const fileThreshold = getThreshold(
+          relPath,
+          threshold,
+          thresholdsByPattern
+        );
+        if (!chunkCoverage && severity.belowThreshold !== "off" && coveragePercent < fileThreshold) {
+          context.report({
+            node,
+            messageId: "belowThreshold",
+            data: {
+              fileName: basename2(filename),
+              coverage: String(coveragePercent),
+              threshold: String(fileThreshold)
+            }
+          });
+        }
+        if (chunkCoverage && chunkSeverity !== "off" && fileCoverage) {
+          const chunks = analyzeChunks(
+            context.sourceCode.ast,
+            filename,
+            fileCoverage
+          );
+          for (const chunk of chunks) {
+            const chunkThresholdValue = getChunkThreshold(chunk, {
+              focusNonReact,
+              chunkThreshold,
+              relaxedThreshold
+            });
+            if (chunk.coverage.percentage < chunkThresholdValue) {
+              const messageId = chunk.coverage.functionCalled ? "chunkBelowThreshold" : "untestedFunction";
+              context.report({
+                loc: chunk.declarationLoc,
+                messageId,
+                data: {
+                  name: chunk.name,
+                  category: chunk.category,
+                  coverage: String(chunk.coverage.percentage),
+                  threshold: String(chunkThresholdValue)
+                }
+              });
+            }
+          }
+        }
+        if (aggregateSeverity !== "off" && (filename.endsWith(".tsx") || filename.endsWith(".jsx"))) {
+          const hasJSX = checkForJSX(context.sourceCode.ast);
+          if (hasJSX) {
+            const aggregateResult = aggregateCoverage(
+              filename,
+              projectRoot,
+              coverage
+            );
+            if (aggregateResult.aggregateCoverage < aggregateThreshold) {
+              const lowestFile = aggregateResult.lowestCoverageFile;
+              context.report({
+                node,
+                messageId: "belowAggregateThreshold",
+                data: {
+                  coverage: String(
+                    Math.round(aggregateResult.aggregateCoverage)
+                  ),
+                  threshold: String(aggregateThreshold),
+                  fileCount: String(aggregateResult.totalFiles),
+                  lowestFile: lowestFile ? basename2(lowestFile.path) : "N/A",
+                  lowestCoverage: lowestFile ? String(Math.round(lowestFile.percentage)) : "N/A"
+                }
+              });
+            }
+          }
+        }
+        if (jsxSeverity !== "off" && jsxElements.length > 0 && coverage) {
+          const fileRelPath = relPath.startsWith("/") ? relPath : `/${relPath}`;
+          for (const { node: jsxNode, ancestors } of jsxElements) {
+            const hasEventHandlers = jsxNode.openingElement.attributes.some(
+              (attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && /^on[A-Z]/.test(attr.name.name)
+            );
+            if (!hasEventHandlers) {
+              continue;
+            }
+            const result = analyzeJSXElementCoverage(
+              jsxNode,
+              fileRelPath,
+              coverage,
+              ancestors,
+              projectRoot
+            );
+            if (result.coverage.percentage < jsxThreshold) {
+              const openingElement = jsxNode.openingElement;
+              let tagName = "unknown";
+              if (openingElement.name.type === "JSXIdentifier") {
+                tagName = openingElement.name.name;
+              } else if (openingElement.name.type === "JSXMemberExpression") {
+                let current = openingElement.name;
+                const parts = [];
+                while (current.type === "JSXMemberExpression") {
+                  if (current.property.type === "JSXIdentifier") {
+                    parts.unshift(current.property.name);
+                  }
+                  current = current.object;
+                }
+                if (current.type === "JSXIdentifier") {
+                  parts.unshift(current.name);
+                }
+                tagName = parts.join(".");
+              }
+              context.report({
+                node: jsxNode,
+                messageId: "jsxBelowThreshold",
+                data: {
+                  tagName,
+                  coverage: String(result.coverage.percentage),
+                  threshold: String(jsxThreshold),
+                  dataLoc: result.dataLoc
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+function checkForJSX(ast, visited = /* @__PURE__ */ new WeakSet()) {
+  if (!ast || typeof ast !== "object") return false;
+  if (visited.has(ast)) return false;
+  visited.add(ast);
+  const node = ast;
+  if (node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "JSXText") {
+    return true;
+  }
+  const childKeys = [
+    "body",
+    "declarations",
+    "declaration",
+    "expression",
+    "expressions",
+    "argument",
+    "arguments",
+    "callee",
+    "elements",
+    "properties",
+    "value",
+    "init",
+    "consequent",
+    "alternate",
+    "test",
+    "left",
+    "right",
+    "object",
+    "property",
+    "children",
+    "openingElement",
+    "closingElement",
+    "attributes"
+  ];
+  for (const key of childKeys) {
+    const child = node[key];
+    if (child && typeof child === "object") {
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (checkForJSX(item, visited)) return true;
+        }
+      } else {
+        if (checkForJSX(child, visited)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+export {
+  meta,
+  clearCoverageCache,
+  require_test_coverage_default
+};
+//# sourceMappingURL=chunk-MSJUSFNN.js.map