uilint-eslint 0.1.16 → 0.1.18

package/dist/index.js

@@ -267,36 +267,129 @@ var COLOR_PREFIXES = [
   "to-"
 ];
 var EXEMPT_SUFFIXES = ["transparent", "inherit", "current", "auto", "none"];
-var COLOR_NAMES = /* @__PURE__ */ new Set([
-  // Grayscale
-  "slate",
-  "gray",
-  "zinc",
-  "neutral",
-  "stone",
-  // Colors
-  "red",
-  "orange",
-  "amber",
-  "yellow",
-  "lime",
-  "green",
-  "emerald",
-  "teal",
-  "cyan",
-  "sky",
-  "blue",
-  "indigo",
-  "violet",
-  "purple",
-  "fuchsia",
-  "pink",
-  "rose",
-  // Special
-  "black",
-  "white"
+var NON_COLOR_UTILITIES = /* @__PURE__ */ new Set([
+  // Exempt values (colorless or inherited) - don't need dark variants
+  "transparent",
+  "inherit",
+  "current",
+  "auto",
+  "none",
+  // text- utilities that aren't colors
+  "xs",
+  "sm",
+  "base",
+  "lg",
+  "xl",
+  "2xl",
+  "3xl",
+  "4xl",
+  "5xl",
+  "6xl",
+  "7xl",
+  "8xl",
+  "9xl",
+  "left",
+  "center",
+  "right",
+  "justify",
+  "start",
+  "end",
+  "wrap",
+  "nowrap",
+  "balance",
+  "pretty",
+  "ellipsis",
+  "clip",
+  // border- utilities that aren't colors
+  "0",
+  "2",
+  "4",
+  "8",
+  "solid",
+  "dashed",
+  "dotted",
+  "double",
+  "hidden",
+  "collapse",
+  "separate",
+  // shadow- utilities that aren't colors
+  // Note: "sm", "lg", "xl", "2xl" already included above
+  "md",
+  "inner",
+  // ring- utilities that aren't colors
+  // Note: "0", "2", "4", "8" already included above
+  "1",
+  "inset",
+  // outline- utilities that aren't colors
+  // Note: numeric values already included
+  "offset-0",
+  "offset-1",
+  "offset-2",
+  "offset-4",
+  "offset-8",
+  // decoration- utilities that aren't colors
+  // Note: "solid", "double", "dotted", "dashed" already included
+  "wavy",
+  "from-font",
+  "clone",
+  "slice",
+  // divide- utilities that aren't colors
+  "x",
+  "y",
+  "x-0",
+  "x-2",
+  "x-4",
+  "x-8",
+  "y-0",
+  "y-2",
+  "y-4",
+  "y-8",
+  "x-reverse",
+  "y-reverse",
+  // gradient direction utilities (from-, via-, to- prefixes)
+  "t",
+  "tr",
+  "r",
+  "br",
+  "b",
+  "bl",
+  "l",
+  "tl"
 ]);
-var COLOR_VALUE_PATTERN = /^(?:(?:slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d{1,3}(?:\/\d+)?|black|white|inherit|current|transparent|\[.+\])$/;
+var SEMANTIC_COLOR_NAMES = /* @__PURE__ */ new Set([
+  // Core shadcn colors
+  "background",
+  "foreground",
+  // Component colors
+  "card",
+  "card-foreground",
+  "popover",
+  "popover-foreground",
+  "primary",
+  "primary-foreground",
+  "secondary",
+  "secondary-foreground",
+  "muted",
+  "muted-foreground",
+  "accent",
+  "accent-foreground",
+  "destructive",
+  "destructive-foreground",
+  // Form/UI colors
+  "border",
+  "input",
+  "ring",
+  // Sidebar colors (shadcn sidebar component)
+  "sidebar",
+  "sidebar-foreground",
+  "sidebar-border",
+  "sidebar-primary",
+  "sidebar-primary-foreground",
+  "sidebar-accent",
+  "sidebar-accent-foreground",
+  "sidebar-ring"
+]);
+var CHART_COLOR_PATTERN = /^chart-\d+$/;
 function hasDarkVariant(className) {
   const parts = className.split(":");
   const variants = parts.slice(0, -1);
@@ -312,20 +405,28 @@ function getColorPrefix(baseClass) {
   );
   return sortedPrefixes.find((p) => baseClass.startsWith(p)) || null;
 }
-function isColorValue(baseClass, prefix) {
-  const value = baseClass.slice(prefix.length);
-  if (COLOR_VALUE_PATTERN.test(value)) {
+function isSemanticColor(value) {
+  if (SEMANTIC_COLOR_NAMES.has(value)) {
     return true;
   }
-  const firstPart = value.split("-")[0];
-  if (COLOR_NAMES.has(firstPart)) {
-    return true;
-  }
-  if (value.startsWith("[") && value.endsWith("]")) {
+  if (CHART_COLOR_PATTERN.test(value)) {
     return true;
   }
   return false;
 }
+function isColorValue(baseClass, prefix) {
+  const value = baseClass.slice(prefix.length);
+  if (!value) {
+    return false;
+  }
+  if (isSemanticColor(value)) {
+    return false;
+  }
+  if (NON_COLOR_UTILITIES.has(value)) {
+    return false;
+  }
+  return true;
+}
 function isExempt(baseClass) {
   return EXEMPT_SUFFIXES.some((suffix) => baseClass.endsWith(suffix));
 }
@@ -715,78 +816,602 @@ var prefer_zustand_state_management_default = createRule({
   }
 });
 
-// src/rules/no-mixed-component-libraries.ts
+// src/utils/export-resolver.ts
+import { ResolverFactory } from "oxc-resolver";
+import { parse } from "@typescript-eslint/typescript-estree";
+import { readFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+var resolverFactory = null;
+var exportCache = /* @__PURE__ */ new Map();
+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 (existsSync(candidate)) {
+          return candidate;
+        }
+        const indexCandidate = join(projectRoot, relativePath, `index${ext}`);
+        if (existsSync(indexCandidate)) {
+          return indexCandidate;
+        }
+      }
+    }
+  }
+  if (importSource.startsWith(".")) {
+    for (const ext of extensions) {
+      const candidate = join(fromDir, importSource + ext);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+      const indexCandidate = join(fromDir, importSource, `index${ext}`);
+      if (existsSync(indexCandidate)) {
+        return indexCandidate;
+      }
+    }
+  }
+  return null;
+}
+function findProjectRoot(fromFile) {
+  let dir = dirname(fromFile);
+  const root = "/";
+  while (dir !== root) {
+    if (existsSync(join(dir, "tsconfig.json"))) {
+      return dir;
+    }
+    if (existsSync(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 = readFileSync(filePath, "utf-8");
+    const ast = parse(content, {
+      jsx: true,
+      loc: true,
+      range: true
+    });
+    astCache.set(filePath, ast);
+    return ast;
+  } catch {
+    return null;
+  }
+}
+function extractExports(filePath) {
+  if (exportCache.has(filePath)) {
+    return exportCache.get(filePath);
+  }
+  const exports = /* @__PURE__ */ new Map();
+  const ast = parseFile(filePath);
+  if (!ast) {
+    exportCache.set(filePath, exports);
+    return exports;
+  }
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "FunctionDeclaration" && node.declaration.id) {
+      exports.set(node.declaration.id.name, {
+        localName: node.declaration.id.name
+      });
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      for (const decl of node.declaration.declarations) {
+        if (decl.id.type === "Identifier") {
+          exports.set(decl.id.name, { localName: decl.id.name });
+        }
+      }
+    }
+    if (node.type === "ExportNamedDeclaration" && node.specifiers.length > 0) {
+      const source = node.source?.value;
+      for (const spec of node.specifiers) {
+        if (spec.type === "ExportSpecifier") {
+          const exportedName = spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value;
+          const localName = spec.local.type === "Identifier" ? spec.local.name : spec.local.value;
+          exports.set(exportedName, {
+            localName,
+            reexportSource: source
+          });
+        }
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
+      exports.set("default", { localName: node.declaration.id.name });
+    }
+    if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "Identifier") {
+      exports.set("default", { localName: node.declaration.name });
+    }
+  }
+  exportCache.set(filePath, exports);
+  return exports;
+}
+function resolveExport(exportName, filePath, visited = /* @__PURE__ */ new Set()) {
+  const key = `${filePath}::${exportName}`;
+  if (visited.has(key)) {
+    return null;
+  }
+  visited.add(key);
+  const exports = extractExports(filePath);
+  const exportInfo = exports.get(exportName);
+  if (!exportInfo) {
+    return null;
+  }
+  if (exportInfo.reexportSource) {
+    const resolvedPath = resolveImportPath(exportInfo.reexportSource, filePath);
+    if (resolvedPath) {
+      return resolveExport(exportInfo.localName, resolvedPath, visited);
+    }
+    return null;
+  }
+  return {
+    name: exportName,
+    filePath,
+    localName: exportInfo.localName,
+    isReexport: false
+  };
+}
+
+// src/utils/component-parser.ts
 var LIBRARY_PATTERNS = {
   shadcn: ["@/components/ui", "@radix-ui/", "components/ui/"],
-  mui: ["@mui/material", "@mui/icons-material", "@emotion/"]
+  mui: ["@mui/material", "@mui/icons-material", "@emotion/"],
+  chakra: ["@chakra-ui/"],
+  antd: ["antd", "@ant-design/"]
 };
+function extractImports(ast) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const node of ast.body) {
+    if (node.type === "ImportDeclaration") {
+      const source = node.source.value;
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          imports.set(spec.local.name, source);
+        } else if (spec.type === "ImportDefaultSpecifier") {
+          imports.set(spec.local.name, source);
+        } else if (spec.type === "ImportNamespaceSpecifier") {
+          imports.set(spec.local.name, source);
+        }
+      }
+    }
+  }
+  return imports;
+}
+function detectLibraryFromSource(importSource) {
+  for (const [library, patterns] of Object.entries(LIBRARY_PATTERNS)) {
+    if (patterns.some((p) => importSource.includes(p))) {
+      return library;
+    }
+  }
+  return null;
+}
+function findComponentDefinition(ast, componentName) {
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "FunctionDeclaration" && node.declaration.id?.name === componentName) {
+      return node.declaration;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      for (const decl of node.declaration.declarations) {
+        if (decl.id.type === "Identifier" && decl.id.name === componentName && decl.init?.type === "ArrowFunctionExpression") {
+          return decl.init;
+        }
+      }
+    }
+    if (node.type === "FunctionDeclaration" && node.id?.name === componentName) {
+      return node;
+    }
+    if (node.type === "VariableDeclaration") {
+      for (const decl of node.declarations) {
+        if (decl.id.type === "Identifier" && decl.id.name === componentName && decl.init?.type === "ArrowFunctionExpression") {
+          return decl.init;
+        }
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "FunctionDeclaration" && node.declaration.id?.name === componentName) {
+      return node.declaration;
+    }
+  }
+  return null;
+}
+function extractTailwindClasses(classString) {
+  return classString.split(/\s+/).filter(Boolean);
+}
+function traverseForStyling(node, imports, result) {
+  if (!node || typeof node !== "object") return;
+  if (node.type === "JSXElement" && node.openingElement) {
+    const opening = node.openingElement;
+    if (opening.name.type === "JSXIdentifier" && /^[A-Z]/.test(opening.name.name)) {
+      const componentName = opening.name.name;
+      const importSource = imports.get(componentName);
+      if (importSource) {
+        result.usedComponents.push({
+          name: componentName,
+          importSource,
+          line: opening.loc.start.line,
+          column: opening.loc.start.column
+        });
+        const library = detectLibraryFromSource(importSource);
+        if (library && !result.directLibrary) {
+          result.directLibrary = library;
+        }
+      }
+    }
+    if (opening.name.type === "JSXMemberExpression") {
+      let objectName = null;
+      let current = opening.name.object;
+      while (current.type === "JSXMemberExpression") {
+        current = current.object;
+      }
+      if (current.type === "JSXIdentifier") {
+        objectName = current.name;
+      }
+      if (objectName) {
+        const importSource = imports.get(objectName);
+        if (importSource) {
+          const library = detectLibraryFromSource(importSource);
+          if (library && !result.directLibrary) {
+            result.directLibrary = library;
+          }
+        }
+      }
+    }
+    for (const attr of opening.attributes) {
+      if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && (attr.name.name === "className" || attr.name.name === "class")) {
+        if (attr.value?.type === "Literal" && typeof attr.value.value === "string") {
+          result.tailwindClasses.push(
+            ...extractTailwindClasses(attr.value.value)
+          );
+        }
+        if (attr.value?.type === "JSXExpressionContainer") {
+          const expr = attr.value.expression;
+          if (expr.type === "Literal" && typeof expr.value === "string") {
+            result.tailwindClasses.push(...extractTailwindClasses(expr.value));
+          }
+          if (expr.type === "TemplateLiteral") {
+            for (const quasi of expr.quasis) {
+              result.tailwindClasses.push(
+                ...extractTailwindClasses(quasi.value.raw)
+              );
+            }
+          }
+        }
+      }
+      if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "style") {
+        if (attr.value?.type === "JSXExpressionContainer") {
+          result.inlineStyles.push("[inline style]");
+        }
+      }
+    }
+  }
+  if (node.type === "CallExpression" && node.callee.type === "Identifier" && ["cn", "clsx", "classnames", "twMerge"].includes(node.callee.name)) {
+    for (const arg of node.arguments) {
+      if (arg.type === "Literal" && typeof arg.value === "string") {
+        result.tailwindClasses.push(...extractTailwindClasses(arg.value));
+      }
+      if (arg.type === "TemplateLiteral") {
+        for (const quasi of arg.quasis) {
+          result.tailwindClasses.push(
+            ...extractTailwindClasses(quasi.value.raw)
+          );
+        }
+      }
+    }
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "parent" || key === "loc" || key === "range") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object") {
+          traverseForStyling(item, imports, result);
+        }
+      }
+    } else if (child && typeof child === "object") {
+      traverseForStyling(child, imports, result);
+    }
+  }
+}
+function parseComponentBody(filePath, componentName) {
+  const ast = parseFile(filePath);
+  if (!ast) return null;
+  const imports = extractImports(ast);
+  const componentDef = findComponentDefinition(ast, componentName);
+  if (!componentDef) {
+    return null;
+  }
+  const result = {
+    tailwindClasses: [],
+    inlineStyles: [],
+    usedComponents: [],
+    directLibrary: null
+  };
+  if (componentDef.body) {
+    traverseForStyling(componentDef.body, imports, result);
+  }
+  result.tailwindClasses = [...new Set(result.tailwindClasses)];
+  return result;
+}
+
+// src/utils/import-graph.ts
+var componentLibraryCache = /* @__PURE__ */ new Map();
+function getComponentLibrary(contextFilePath, componentName, importSource) {
+  const directLibrary = detectLibraryFromSource(importSource);
+  if (directLibrary) {
+    return {
+      library: directLibrary,
+      internalLibraries: /* @__PURE__ */ new Set(),
+      libraryEvidence: [],
+      isLocalComponent: false
+    };
+  }
+  const resolvedPath = resolveImportPath(importSource, contextFilePath);
+  if (!resolvedPath) {
+    return {
+      library: null,
+      internalLibraries: /* @__PURE__ */ new Set(),
+      libraryEvidence: [],
+      isLocalComponent: false
+    };
+  }
+  const cacheKey = `${resolvedPath}::${componentName}`;
+  if (componentLibraryCache.has(cacheKey)) {
+    return componentLibraryCache.get(cacheKey);
+  }
+  const resolvedExport = resolveExport(componentName, resolvedPath);
+  const actualFilePath = resolvedExport?.filePath ?? resolvedPath;
+  const actualComponentName = resolvedExport?.localName ?? componentName;
+  const result = analyzeComponentLibraries(
+    actualFilePath,
+    actualComponentName,
+    /* @__PURE__ */ new Set([cacheKey])
+    // Track visited to prevent cycles
+  );
+  componentLibraryCache.set(cacheKey, result);
+  return result;
+}
+function analyzeComponentLibraries(filePath, componentName, visited) {
+  const styleInfo = parseComponentBody(filePath, componentName);
+  if (!styleInfo) {
+    return {
+      library: null,
+      internalLibraries: /* @__PURE__ */ new Set(),
+      libraryEvidence: [],
+      isLocalComponent: true
+    };
+  }
+  const internalLibraries = /* @__PURE__ */ new Set();
+  const libraryEvidence = [];
+  if (styleInfo.directLibrary) {
+    internalLibraries.add(styleInfo.directLibrary);
+  }
+  for (const usedComponent of styleInfo.usedComponents) {
+    const usedLibrary = detectLibraryFromSource(usedComponent.importSource);
+    if (usedLibrary) {
+      internalLibraries.add(usedLibrary);
+      libraryEvidence.push({
+        componentName: usedComponent.name,
+        library: usedLibrary
+      });
+    } else {
+      const resolvedPath = resolveImportPath(usedComponent.importSource, filePath);
+      if (resolvedPath) {
+        const cacheKey = `${resolvedPath}::${usedComponent.name}`;
+        if (!visited.has(cacheKey)) {
+          visited.add(cacheKey);
+          let nestedInfo;
+          if (componentLibraryCache.has(cacheKey)) {
+            nestedInfo = componentLibraryCache.get(cacheKey);
+          } else {
+            const resolvedExport = resolveExport(usedComponent.name, resolvedPath);
+            const actualFilePath = resolvedExport?.filePath ?? resolvedPath;
+            const actualComponentName = resolvedExport?.localName ?? usedComponent.name;
+            nestedInfo = analyzeComponentLibraries(
+              actualFilePath,
+              actualComponentName,
+              visited
+            );
+            componentLibraryCache.set(cacheKey, nestedInfo);
+          }
+          if (nestedInfo.library) {
+            internalLibraries.add(nestedInfo.library);
+            libraryEvidence.push({
+              componentName: usedComponent.name,
+              library: nestedInfo.library
+            });
+          }
+          for (const lib of nestedInfo.internalLibraries) {
+            internalLibraries.add(lib);
+          }
+          for (const evidence of nestedInfo.libraryEvidence) {
+            libraryEvidence.push({
+              componentName: `${usedComponent.name} \u2192 ${evidence.componentName}`,
+              library: evidence.library
+            });
+          }
+        }
+      }
+    }
+  }
+  return {
+    library: styleInfo.directLibrary,
+    internalLibraries,
+    libraryEvidence,
+    isLocalComponent: true
+  };
+}
+
+// src/rules/no-mixed-component-libraries.ts
 var no_mixed_component_libraries_default = createRule({
   name: "no-mixed-component-libraries",
   meta: {
     type: "problem",
     docs: {
-      description: "Forbid mixing component libraries in the same file"
+      description: "Forbid using non-preferred UI component libraries. Reports at JSX usage sites, including transitive usage."
     },
     messages: {
-      mixedLibraries: "Mixing {{lib1}} and {{lib2}} components. Choose one library per file.",
-      nonPreferredLibrary: "Using {{lib}} components, but {{preferred}} is the preferred library. Use {{preferred}} instead."
+      nonPreferredLibrary: "Component <{{component}}> is from {{library}}, but {{preferred}} is the preferred library.",
+      transitiveNonPreferred: "Component <{{component}}> internally uses {{libraries}} components ({{internalComponents}}). The preferred library is {{preferred}}."
     },
     schema: [
       {
         type: "object",
         properties: {
-          libraries: {
-            type: "array",
-            items: { type: "string", enum: ["shadcn", "mui"] }
-          },
           preferred: {
             type: "string",
-            enum: ["shadcn", "mui"]
+            enum: ["shadcn", "mui", "chakra", "antd"],
+            description: "The preferred UI library"
+          },
+          libraries: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: ["shadcn", "mui", "chakra", "antd"]
+            },
+            description: "Libraries to detect (defaults to all)"
           }
         },
+        required: ["preferred"],
         additionalProperties: false
       }
     ]
   },
-  defaultOptions: [{ libraries: ["shadcn", "mui"] }],
+  defaultOptions: [
+    { preferred: "shadcn", libraries: ["shadcn", "mui", "chakra", "antd"] }
+  ],
   create(context) {
-    const options = context.options[0] || {};
-    const libraries = options.libraries || ["shadcn", "mui"];
+    const options = context.options[0];
     const preferred = options.preferred;
-    const detected = /* @__PURE__ */ new Map();
+    const importMap = /* @__PURE__ */ new Map();
+    const componentUsages = [];
     return {
       ImportDeclaration(node) {
         const source = node.source.value;
-        for (const lib of libraries) {
-          const patterns = LIBRARY_PATTERNS[lib];
-          if (patterns?.some((p) => source.includes(p))) {
-            if (!detected.has(lib)) {
-              detected.set(lib, node);
-            }
+        for (const spec of node.specifiers) {
+          if (spec.type === "ImportSpecifier") {
+            importMap.set(spec.local.name, source);
+          } else if (spec.type === "ImportDefaultSpecifier") {
+            importMap.set(spec.local.name, source);
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            importMap.set(spec.local.name, source);
           }
         }
       },
-      "Program:exit"() {
-        if (detected.size > 1) {
-          const libs = [...detected.keys()];
-          const secondLib = libs[1];
-          const secondNode = detected.get(secondLib);
-          context.report({
-            node: secondNode,
-            messageId: "mixedLibraries",
-            data: { lib1: libs[0], lib2: secondLib }
-          });
+      JSXOpeningElement(node) {
+        let componentName = null;
+        if (node.name.type === "JSXIdentifier") {
+          componentName = node.name.name;
+        } else if (node.name.type === "JSXMemberExpression") {
+          let current = node.name.object;
+          while (current.type === "JSXMemberExpression") {
+            current = current.object;
+          }
+          if (current.type === "JSXIdentifier") {
+            componentName = current.name;
+          }
+        }
+        if (!componentName || !/^[A-Z]/.test(componentName)) {
+          return;
+        }
+        const importSource = importMap.get(componentName);
+        if (!importSource) {
           return;
         }
-        if (preferred && detected.size === 1) {
-          const usedLib = [...detected.keys()][0];
-          if (usedLib && usedLib !== preferred) {
-            const node = detected.get(usedLib);
+        componentUsages.push({
+          node,
+          componentName,
+          importSource
+        });
+      },
+      "Program:exit"() {
+        const filename = context.filename || context.getFilename();
+        for (const usage of componentUsages) {
+          const libraryInfo = getComponentLibrary(
+            filename,
+            usage.componentName,
+            usage.importSource
+          );
+          if (libraryInfo.library && libraryInfo.library !== preferred) {
             context.report({
-              node,
+              node: usage.node,
               messageId: "nonPreferredLibrary",
-              data: { lib: usedLib, preferred }
+              data: {
+                component: usage.componentName,
+                library: libraryInfo.library,
+                preferred
+              }
             });
+            continue;
+          }
+          if (libraryInfo.isLocalComponent && libraryInfo.internalLibraries.size > 0) {
+            const nonPreferredLibs = [...libraryInfo.internalLibraries].filter(
+              (lib) => lib !== preferred
+            );
+            if (nonPreferredLibs.length > 0) {
+              const internalComponents = libraryInfo.libraryEvidence.filter((e) => e.library !== preferred).map((e) => e.componentName).slice(0, 3).join(", ");
+              context.report({
+                node: usage.node,
+                messageId: "transitiveNonPreferred",
+                data: {
+                  component: usage.componentName,
+                  libraries: nonPreferredLibs.join(", "),
+                  internalComponents: internalComponents || "unknown",
+                  preferred
+                }
+              });
+            }
           }
         }
       }
@@ -795,13 +1420,13 @@ var no_mixed_component_libraries_default = createRule({
 });
 
 // src/rules/semantic.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { spawnSync } from "child_process";
-import { dirname as dirname3, join as join3, relative } from "path";
+import { dirname as dirname4, join as join4, relative } from "path";
 
 // src/utils/cache.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
 var xxhashInstance = null;
 async function getXxhash() {
   if (!xxhashInstance) {
@@ -831,15 +1456,15 @@ function hashContentSync(content) {
 var CACHE_VERSION = 1;
 var CACHE_FILE = ".uilint/.cache/eslint-semantic.json";
 function getCachePath(projectRoot) {
-  return join(projectRoot, CACHE_FILE);
+  return join2(projectRoot, CACHE_FILE);
 }
 function loadCache(projectRoot) {
   const cachePath = getCachePath(projectRoot);
-  if (!existsSync(cachePath)) {
+  if (!existsSync2(cachePath)) {
     return { version: CACHE_VERSION, entries: {} };
   }
   try {
-    const content = readFileSync(cachePath, "utf-8");
+    const content = readFileSync2(cachePath, "utf-8");
     const cache = JSON.parse(content);
     if (cache.version !== CACHE_VERSION) {
       return { version: CACHE_VERSION, entries: {} };
@@ -852,8 +1477,8 @@ function loadCache(projectRoot) {
 function saveCache(projectRoot, cache) {
   const cachePath = getCachePath(projectRoot);
   try {
-    const cacheDir = dirname(cachePath);
-    if (!existsSync(cacheDir)) {
+    const cacheDir = dirname2(cachePath);
+    if (!existsSync2(cacheDir)) {
       mkdirSync(cacheDir, { recursive: true });
     }
     writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
@@ -884,8 +1509,8 @@ function clearCache(projectRoot) {
 }
 
 // src/utils/styleguide-loader.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, isAbsolute, join as join2, resolve } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, isAbsolute, join as join3, resolve } from "path";
 var DEFAULT_STYLEGUIDE_PATHS = [
   ".uilint/styleguide.md",
   ".uilint/styleguide.yaml",
@@ -894,10 +1519,10 @@ var DEFAULT_STYLEGUIDE_PATHS = [
 function findWorkspaceRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 20; i++) {
-    if (existsSync2(join2(dir, "pnpm-workspace.yaml")) || existsSync2(join2(dir, ".git"))) {
+    if (existsSync3(join3(dir, "pnpm-workspace.yaml")) || existsSync3(join3(dir, ".git"))) {
       return dir;
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -906,9 +1531,9 @@ function findWorkspaceRoot(startDir) {
 function findNearestPackageRoot(startDir, workspaceRoot) {
   let dir = startDir;
   for (let i = 0; i < 30; i++) {
-    if (existsSync2(join2(dir, "package.json"))) return dir;
+    if (existsSync3(join3(dir, "package.json"))) return dir;
     if (dir === workspaceRoot) break;
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -917,7 +1542,7 @@ function findNearestPackageRoot(startDir, workspaceRoot) {
 function findStyleguidePath(startDir, explicitPath) {
   if (explicitPath) {
     if (isAbsolute(explicitPath)) {
-      return existsSync2(explicitPath) ? explicitPath : null;
+      return existsSync3(explicitPath) ? explicitPath : null;
     }
     const workspaceRoot2 = findWorkspaceRoot(startDir);
     const packageRoot = findNearestPackageRoot(startDir, workspaceRoot2);
@@ -927,7 +1552,7 @@ function findStyleguidePath(startDir, explicitPath) {
       resolve(workspaceRoot2, explicitPath)
     ];
     for (const p of candidates) {
-      if (existsSync2(p)) return p;
+      if (existsSync3(p)) return p;
     }
     return null;
   }
@@ -935,13 +1560,13 @@ function findStyleguidePath(startDir, explicitPath) {
   let dir = startDir;
   while (true) {
     for (const relativePath of DEFAULT_STYLEGUIDE_PATHS) {
-      const fullPath = join2(dir, relativePath);
-      if (existsSync2(fullPath)) {
+      const fullPath = join3(dir, relativePath);
+      if (existsSync3(fullPath)) {
         return fullPath;
       }
     }
     if (dir === workspaceRoot) break;
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -951,7 +1576,7 @@ function loadStyleguide(startDir, explicitPath) {
   const path = findStyleguidePath(startDir, explicitPath);
   if (!path) return null;
   try {
-    return readFileSync2(path, "utf-8");
+    return readFileSync3(path, "utf-8");
   } catch {
     return null;
   }
@@ -960,7 +1585,7 @@ function getStyleguide(startDir, explicitPath) {
   const path = findStyleguidePath(startDir, explicitPath);
   if (!path) return { path: null, content: null };
   try {
-    const content = readFileSync2(path, "utf-8");
+    const content = readFileSync3(path, "utf-8");
     return { path, content };
   } catch {
     return { path, content: null };
@@ -1003,7 +1628,7 @@ var semantic_default = createRule({
   create(context) {
     const options = context.options[0] || {};
     const filePath = context.filename;
-    const fileDir = dirname3(filePath);
+    const fileDir = dirname4(filePath);
     const { path: styleguidePath, content: styleguide } = getStyleguide(
       fileDir,
       options.styleguidePath
@@ -1025,7 +1650,7 @@ var semantic_default = createRule({
     }
     let fileContent;
     try {
-      fileContent = readFileSync3(filePath, "utf-8");
+      fileContent = readFileSync4(filePath, "utf-8");
     } catch {
       console.error(`[uilint] Failed to read file ${filePath}`);
       return {
@@ -1040,7 +1665,7 @@ var semantic_default = createRule({
     }
     const fileHash = hashContentSync(fileContent);
     const styleguideHash = hashContentSync(styleguide);
-    const projectRoot = findProjectRoot(fileDir);
+    const projectRoot = findProjectRoot2(fileDir);
     const relativeFilePath = relative(projectRoot, filePath);
     const cached = getCacheEntry(
       projectRoot,
@@ -1093,13 +1718,13 @@ var semantic_default = createRule({
     };
   }
 });
-function findProjectRoot(startDir) {
+function findProjectRoot2(startDir) {
   let dir = startDir;
   for (let i = 0; i < 20; i++) {
-    if (existsSync3(join3(dir, "package.json"))) {
+    if (existsSync4(join4(dir, "package.json"))) {
       return dir;
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }