uilint-eslint 0.2.29 → 0.2.30

package/dist/index.d.ts

@@ -79,6 +79,17 @@ interface RuleMeta {
      * Example: ["coverage-aggregator", "dependency-graph"]
      */
     internalDependencies?: string[];
+    /**
+     * Whether this rule is directory-based (has lib/ folder with utilities).
+     * Directory-based rules are installed as folders with index.ts and lib/ subdirectory.
+     * Single-file rules are installed as single .ts files.
+     *
+     * When true, ESLint config imports will use:
+     *   ./.uilint/rules/rule-id/index.js
+     * When false (default):
+     *   ./.uilint/rules/rule-id.js
+     */
+    isDirectoryBased?: boolean;
 }
 /**
  * Helper to define rule metadata with type safety

package/dist/index.js

@@ -1108,7 +1108,7 @@ var prefer_zustand_state_management_default = createRule({
   }
 });
 
-// src/utils/export-resolver.ts
+// src/rules/no-mixed-component-libraries/lib/export-resolver.ts
 import { ResolverFactory } from "oxc-resolver";
 import { parse } from "@typescript-eslint/typescript-estree";
 import { readFileSync, existsSync } from "fs";
@@ -1302,7 +1302,7 @@ function clearResolverCaches() {
   resolvedPathCache.clear();
 }
 
-// src/utils/component-parser.ts
+// src/rules/no-mixed-component-libraries/lib/component-parser.ts
 var LIBRARY_PATTERNS = {
   shadcn: ["@/components/ui", "@radix-ui/", "components/ui/"],
   mui: ["@mui/material", "@mui/icons-material", "@emotion/"],
@@ -1482,7 +1482,7 @@ function parseComponentBody(filePath, componentName) {
   return result;
 }
 
-// src/utils/import-graph.ts
+// src/rules/no-mixed-component-libraries/lib/import-graph.ts
 var componentLibraryCache = /* @__PURE__ */ new Map();
 function getComponentLibrary(contextFilePath, componentName, importSource) {
   const directLibrary = detectLibraryFromSource(importSource);
@@ -1600,7 +1600,7 @@ function clearCache() {
   clearResolverCaches();
 }
 
-// src/rules/no-mixed-component-libraries.ts
+// src/rules/no-mixed-component-libraries/index.ts
 var meta6 = defineRuleMeta({
   id: "no-mixed-component-libraries",
   name: "No Mixed Component Libraries",
@@ -1680,7 +1680,8 @@ import { Card } from '@/components/ui/card';
 - **mui**: Material-UI (\`@mui/material\`, \`@mui/joy\`)
 - **chakra**: Chakra UI (\`@chakra-ui/react\`)
 - **antd**: Ant Design (\`antd\`)
-`
+`,
+  isDirectoryBased: true
 });
 var no_mixed_component_libraries_default = createRule({
   name: "no-mixed-component-libraries",
@@ -1807,12 +1808,12 @@ var no_mixed_component_libraries_default = createRule({
   }
 });
 
-// src/rules/semantic.ts
+// src/rules/semantic/index.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { spawnSync } from "child_process";
 import { dirname as dirname4, join as join4, relative } from "path";
 
-// src/utils/cache.ts
+// src/rules/semantic/lib/cache.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
 var xxhashInstance = null;
@@ -1896,7 +1897,7 @@ function clearCache2(projectRoot) {
   saveCache(projectRoot, { version: CACHE_VERSION, entries: {} });
 }
 
-// src/utils/styleguide-loader.ts
+// src/rules/semantic/lib/styleguide-loader.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname3, isAbsolute, join as join3, resolve } from "path";
 var DEFAULT_STYLEGUIDE_PATHS = [
@@ -1980,7 +1981,7 @@ function getStyleguide(startDir, explicitPath) {
   }
 }
 
-// src/rules/semantic.ts
+// src/rules/semantic/index.ts
 import { UILINT_DEFAULT_OLLAMA_MODEL } from "uilint-core";
 import { buildSourceScanPrompt } from "uilint-core";
 var meta7 = defineRuleMeta({
@@ -2067,7 +2068,8 @@ styleguide. It catches semantic issues that pattern-based rules can't detect, li
 - First run may be slow as the model loads; subsequent runs use cache
 - Works best with detailed, specific styleguide documentation
 - Set to "off" in CI to avoid slow builds (use pre-commit hooks locally)
-`
+`,
+  isDirectoryBased: true
 });
 var semantic_default = createRule({
   name: "semantic",
@@ -4708,12 +4710,12 @@ var no_semantic_duplicates_default = createRule({
   }
 });
 
-// src/rules/require-test-coverage.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
-import { dirname as dirname7, join as join7, basename as basename2, relative as relative4 } from "path";
+// src/rules/require-test-coverage/index.ts
+import { existsSync as existsSync10, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
+import { dirname as dirname8, join as join8, basename as basename2, relative as relative4 } from "path";
 import { execSync } from "child_process";
 
-// src/utils/file-categorizer.ts
+// src/rules/require-test-coverage/lib/file-categorizer.ts
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { basename } from "path";
 import { parse as parse2 } from "@typescript-eslint/typescript-estree";
@@ -4876,8 +4878,127 @@ function analyzeExports(ast) {
   };
 }
 
-// src/utils/dependency-graph.ts
-import { existsSync as existsSync8, statSync } from "fs";
+// src/rules/require-test-coverage/lib/dependency-graph.ts
+import { existsSync as existsSync9, statSync } from "fs";
+
+// src/rules/require-test-coverage/lib/export-resolver.ts
+import { ResolverFactory as ResolverFactory2 } from "oxc-resolver";
+import { parse as parse3 } from "@typescript-eslint/typescript-estree";
+import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
+import { dirname as dirname7, join as join7 } from "path";
+var resolverFactory2 = null;
+var astCache2 = /* @__PURE__ */ new Map();
+var resolvedPathCache2 = /* @__PURE__ */ new Map();
+function getResolverFactory2() {
+  if (!resolverFactory2) {
+    resolverFactory2 = new ResolverFactory2({
+      extensions: [".tsx", ".ts", ".jsx", ".js"],
+      mainFields: ["module", "main"],
+      conditionNames: ["import", "require", "node", "default"],
+      // Enable TypeScript path resolution
+      tsconfig: {
+        configFile: "tsconfig.json",
+        references: "auto"
+      }
+    });
+  }
+  return resolverFactory2;
+}
+function resolveImportPath2(importSource, fromFile) {
+  const cacheKey = `${fromFile}::${importSource}`;
+  if (resolvedPathCache2.has(cacheKey)) {
+    return resolvedPathCache2.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/")) {
+      resolvedPathCache2.set(cacheKey, null);
+      return null;
+    }
+    resolvedPathCache2.set(cacheKey, null);
+    return null;
+  }
+  try {
+    const factory = getResolverFactory2();
+    const fromDir = dirname7(fromFile);
+    const result = factory.sync(fromDir, importSource);
+    if (result.path) {
+      resolvedPathCache2.set(cacheKey, result.path);
+      return result.path;
+    }
+  } catch {
+    const resolved = manualResolve2(importSource, fromFile);
+    resolvedPathCache2.set(cacheKey, resolved);
+    return resolved;
+  }
+  resolvedPathCache2.set(cacheKey, null);
+  return null;
+}
+function manualResolve2(importSource, fromFile) {
+  const fromDir = dirname7(fromFile);
+  const extensions = [".tsx", ".ts", ".jsx", ".js"];
+  if (importSource.startsWith("@/")) {
+    const projectRoot = findProjectRoot5(fromFile);
+    if (projectRoot) {
+      const relativePath = importSource.slice(2);
+      for (const ext of extensions) {
+        const candidate = join7(projectRoot, relativePath + ext);
+        if (existsSync8(candidate)) {
+          return candidate;
+        }
+        const indexCandidate = join7(projectRoot, relativePath, `index${ext}`);
+        if (existsSync8(indexCandidate)) {
+          return indexCandidate;
+        }
+      }
+    }
+  }
+  if (importSource.startsWith(".")) {
+    for (const ext of extensions) {
+      const candidate = join7(fromDir, importSource + ext);
+      if (existsSync8(candidate)) {
+        return candidate;
+      }
+      const indexCandidate = join7(fromDir, importSource, `index${ext}`);
+      if (existsSync8(indexCandidate)) {
+        return indexCandidate;
+      }
+    }
+  }
+  return null;
+}
+function findProjectRoot5(fromFile) {
+  let dir = dirname7(fromFile);
+  const root = "/";
+  while (dir !== root) {
+    if (existsSync8(join7(dir, "tsconfig.json"))) {
+      return dir;
+    }
+    if (existsSync8(join7(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname7(dir);
+  }
+  return null;
+}
+function parseFile2(filePath) {
+  if (astCache2.has(filePath)) {
+    return astCache2.get(filePath);
+  }
+  try {
+    const content = readFileSync8(filePath, "utf-8");
+    const ast = parse3(content, {
+      jsx: true,
+      loc: true,
+      range: true
+    });
+    astCache2.set(filePath, ast);
+    return ast;
+  } catch {
+    return null;
+  }
+}
+
+// src/rules/require-test-coverage/lib/dependency-graph.ts
 var dependencyCache = /* @__PURE__ */ new Map();
 function buildDependencyGraph(entryFile, projectRoot) {
   const cached = dependencyCache.get(entryFile);
@@ -4911,7 +5032,7 @@ function collectDependencies(filePath, projectRoot, allDependencies, visited) {
   visited.add(filePath);
   const imports = extractImports2(filePath);
   for (const importSource of imports) {
-    const resolvedPath = resolveImportPath(importSource, filePath);
+    const resolvedPath = resolveImportPath2(importSource, filePath);
     if (!resolvedPath) {
       continue;
     }
@@ -4929,10 +5050,10 @@ function collectDependencies(filePath, projectRoot, allDependencies, visited) {
   }
 }
 function extractImports2(filePath) {
-  if (!existsSync8(filePath)) {
+  if (!existsSync9(filePath)) {
     return [];
   }
-  const ast = parseFile(filePath);
+  const ast = parseFile2(filePath);
   if (!ast) {
     return [];
   }
@@ -4979,7 +5100,7 @@ function extractDynamicImports(ast) {
   return imports;
 }
 
-// src/utils/coverage-aggregator.ts
+// src/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]);
@@ -5087,7 +5208,7 @@ function calculateWeightedCoverage(files) {
   return Math.round(percentage * 100) / 100;
 }
 
-// src/utils/jsx-coverage-analyzer.ts
+// src/rules/require-test-coverage/lib/jsx-coverage-analyzer.ts
 function buildDataLoc(filePath, loc) {
   return `${filePath}:${loc.start.line}:${loc.start.column}`;
 }
@@ -5547,7 +5668,7 @@ function findImportsUsedInJSX(jsxNode, ancestors) {
   }
   return importPaths;
 }
-function resolveImportPath2(importPath, currentFilePath, projectRoot) {
+function resolveImportPath3(importPath, currentFilePath, projectRoot) {
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
@@ -5586,7 +5707,7 @@ function aggregateImportCoverage(importPaths, coverage, projectRoot, currentFile
   let totalCovered = 0;
   let totalStatements = 0;
   for (const importPath of importPaths) {
-    const resolvedPath = resolveImportPath2(importPath, currentFilePath, projectRoot);
+    const resolvedPath = resolveImportPath3(importPath, currentFilePath, projectRoot);
     if (!resolvedPath) {
       continue;
     }
@@ -5610,7 +5731,7 @@ function aggregateImportCoverage(importPaths, coverage, projectRoot, currentFile
   return { covered: totalCovered, total: totalStatements };
 }
 
-// src/rules/require-test-coverage.ts
+// src/rules/require-test-coverage/index.ts
 function simpleGlobMatch(pattern, path) {
   const normalizedPath = path.replace(/\\/g, "/");
   const normalizedPattern = pattern.replace(/\\/g, "/");
@@ -5728,32 +5849,26 @@ export function calculate() { ... }  // Warning: No test file found
 export function fetchData() { ... }  // Warning: Coverage below threshold
 \`\`\`
 `,
-  // Declare internal utility dependencies for proper transformation during installation
-  internalDependencies: [
-    "coverage-aggregator",
-    "dependency-graph",
-    "file-categorizer",
-    "jsx-coverage-analyzer"
-  ]
+  isDirectoryBased: true
 });
 var coverageCache = null;
-function findProjectRoot5(startPath) {
+function findProjectRoot6(startPath) {
   let current = startPath;
   let lastPackageJson = null;
-  while (current !== dirname7(current)) {
-    if (existsSync9(join7(current, "package.json"))) {
+  while (current !== dirname8(current)) {
+    if (existsSync10(join8(current, "package.json"))) {
       lastPackageJson = current;
     }
-    if (existsSync9(join7(current, "coverage"))) {
+    if (existsSync10(join8(current, "coverage"))) {
       return current;
     }
-    current = dirname7(current);
+    current = dirname8(current);
   }
   return lastPackageJson || startPath;
 }
 function loadCoverage(projectRoot, coveragePath) {
-  const fullPath = join7(projectRoot, coveragePath);
-  if (!existsSync9(fullPath)) {
+  const fullPath = join8(projectRoot, coveragePath);
+  if (!existsSync10(fullPath)) {
     return null;
   }
   try {
@@ -5762,7 +5877,7 @@ function loadCoverage(projectRoot, coveragePath) {
     if (coverageCache && coverageCache.projectRoot === projectRoot && coverageCache.coveragePath === coveragePath && coverageCache.mtime === mtime) {
       return coverageCache.data;
     }
-    const content = readFileSync9(fullPath, "utf-8");
+    const content = readFileSync10(fullPath, "utf-8");
     const data = JSON.parse(content);
     coverageCache = {
       projectRoot,
@@ -5785,17 +5900,17 @@ function calculateCoverage(fileCoverage) {
   return Math.round(covered / keys.length * 100);
 }
 function testFileExists(filePath, testPatterns) {
-  const dir = dirname7(filePath);
+  const dir = dirname8(filePath);
   const ext = filePath.match(/\.(tsx?|jsx?)$/)?.[0] || ".ts";
   const baseName = basename2(filePath, ext);
   for (const pattern of testPatterns) {
     if (pattern.startsWith("__tests__/")) {
-      const testDir = join7(dir, "__tests__");
-      const testFile = join7(
+      const testDir = join8(dir, "__tests__");
+      const testFile = join8(
         testDir,
         `${baseName}${pattern.replace("__tests__/", "")}`
       );
-      if (existsSync9(testFile)) {
+      if (existsSync10(testFile)) {
         return true;
       }
       for (const testExt of [
@@ -5804,13 +5919,13 @@ function testFileExists(filePath, testPatterns) {
         ".spec.ts",
         ".spec.tsx"
       ]) {
-        if (existsSync9(join7(testDir, `${baseName}${testExt}`))) {
+        if (existsSync10(join8(testDir, `${baseName}${testExt}`))) {
           return true;
         }
       }
     } else {
-      const testFile = join7(dir, `${baseName}${pattern}`);
-      if (existsSync9(testFile)) {
+      const testFile = join8(dir, `${baseName}${pattern}`);
+      if (existsSync10(testFile)) {
         return true;
       }
     }
@@ -6063,7 +6178,7 @@ var require_test_coverage_default = createRule({
     const jsxThreshold = options.jsxThreshold ?? 50;
     const jsxSeverity = options.jsxSeverity ?? "warn";
     const filename = context.filename || context.getFilename();
-    const projectRoot = findProjectRoot5(dirname7(filename));
+    const projectRoot = findProjectRoot6(dirname8(filename));
     const relPath = relative4(projectRoot, filename);
     if (shouldIgnore2(relPath, ignorePatterns)) {
       return {};