@schemyx/mcp 0.1.3 → 0.1.4

package/dist/codebase-scanner/bundle.js

@@ -183,6 +183,8 @@ function createBundle(rootPath, projectType, files) {
     const nodes = [];
     const edges = [];
     const reviewItems = [];
+    const componentStyleContext = createComponentStyleContext(files);
+    enrichUiElementsWithComponentStyles(files, componentStyleContext);
     const styleResolutionContext = createStyleResolutionContext(files);
     for (const file of files) {
         const fileSource = sourceInfo('core.files', 'high', [`path:${file.relPath}`], file);
@@ -722,6 +724,186 @@ function createBundle(rootPath, projectType, files) {
         detected: detectProjectFacts(files),
     };
 }
+function createComponentStyleContext(files) {
+    const byName = new Map();
+    const byHelper = new Map();
+    for (const file of files) {
+        for (const definition of file.componentStyleDefinitions) {
+            if (!byName.has(definition.name)) {
+                byName.set(definition.name, definition);
+            }
+            if (definition.styleHelper && !byHelper.has(definition.styleHelper)) {
+                byHelper.set(definition.styleHelper, definition);
+            }
+        }
+    }
+    return { byName, byHelper };
+}
+function enrichUiElementsWithComponentStyles(files, context) {
+    for (const file of files) {
+        file.uiElements = file.uiElements.map((element) => enrichUiElementWithComponentStyles(element, context));
+        file.uiElements = file.uiElements.map((element) => ({
+            ...element,
+            childSummary: element.childSummary?.map((child) => enrichUiChildWithComponentStyles(child, context)),
+        }));
+        file.classReferences = (0, utils_1.unique)([
+            ...file.classReferences,
+            ...file.uiElements.flatMap((element) => element.classes),
+            ...file.uiElements.flatMap((element) => element.defaultClasses ?? []),
+        ]).slice(0, 500);
+        file.tailwindUtilities = (0, utils_1.unique)([
+            ...file.tailwindUtilities,
+            ...file.uiElements.flatMap((element) => element.classes),
+            ...file.uiElements.flatMap((element) => element.defaultClasses ?? []),
+        ]).slice(0, 160);
+    }
+}
+function enrichUiElementWithComponentStyles(element, context) {
+    const resolved = resolveComponentStyleClasses(element.originalTag, element.styleHelper, element.variants ?? element.styleHelperVariants, context);
+    if (!resolved.classes.length) {
+        return element;
+    }
+    const defaultClasses = mergeTailwindConflictClasses([
+        ...resolved.defaultClasses,
+        ...(element.defaultClasses ?? []),
+    ]);
+    const classes = mergeTailwindConflictClasses([
+        ...resolved.classes,
+        ...element.classes,
+        ...defaultClasses,
+    ]);
+    return {
+        ...element,
+        classes,
+        defaultClasses,
+        classGroups: (0, extractors_1.groupTailwindClasses)(classes),
+        styleHelper: element.styleHelper ?? resolved.styleHelper,
+        ...(element.styleHelperVariants ?? resolved.styleHelperVariants
+            ? {
+                styleHelperVariants: {
+                    ...(resolved.styleHelperVariants ?? {}),
+                    ...(element.styleHelperVariants ?? {}),
+                },
+            }
+            : {}),
+    };
+}
+function enrichUiChildWithComponentStyles(child, context) {
+    const resolved = resolveComponentStyleClasses(child.originalTag, child.styleHelper, child.variants ?? child.styleHelperVariants, context);
+    if (!resolved.classes.length) {
+        return child;
+    }
+    const defaultClasses = mergeTailwindConflictClasses([
+        ...resolved.defaultClasses,
+        ...(child.defaultClasses ?? []),
+    ]);
+    const classes = mergeTailwindConflictClasses([
+        ...resolved.classes,
+        ...child.classes,
+        ...defaultClasses,
+    ]);
+    return {
+        ...child,
+        classes,
+        defaultClasses,
+        styleHelper: child.styleHelper ?? resolved.styleHelper,
+        ...(child.styleHelperVariants ?? resolved.styleHelperVariants
+            ? {
+                styleHelperVariants: {
+                    ...(resolved.styleHelperVariants ?? {}),
+                    ...(child.styleHelperVariants ?? {}),
+                },
+            }
+            : {}),
+    };
+}
+function resolveComponentStyleClasses(componentName, styleHelperName, variants, context) {
+    const wrapper = componentName ? context.byName.get(componentName) : undefined;
+    const helperName = styleHelperName ?? wrapper?.styleHelper;
+    const helper = helperName ? context.byName.get(helperName) : undefined;
+    const helperClasses = helper
+        ? resolveComponentDefinitionClasses(helper, variants)
+        : { classes: [], defaultClasses: [] };
+    const wrapperClasses = wrapper
+        ? resolveComponentDefinitionClasses(wrapper, variants)
+        : { classes: [], defaultClasses: [] };
+    const normalizedVariants = normalizeVariantRecord(variants);
+    return {
+        classes: (0, utils_1.unique)([...wrapperClasses.classes, ...helperClasses.classes]),
+        defaultClasses: (0, utils_1.unique)([...wrapperClasses.defaultClasses, ...helperClasses.defaultClasses]),
+        ...(helperName ? { styleHelper: helperName } : {}),
+        ...(Object.keys(normalizedVariants).length ? { styleHelperVariants: normalizedVariants } : {}),
+    };
+}
+function resolveComponentDefinitionClasses(definition, variants) {
+    const normalizedVariants = normalizeVariantRecord(variants);
+    const defaultClasses = new Set(definition.baseClasses);
+    const classes = new Set(definition.classes);
+    for (const [variantName, variantMap] of Object.entries(definition.variants)) {
+        const requestedVariant = normalizedVariants[variantName] ?? definition.defaultVariants[variantName];
+        if (requestedVariant && variantMap[requestedVariant]) {
+            for (const className of variantMap[requestedVariant]) {
+                defaultClasses.add(className);
+                classes.add(className);
+            }
+        }
+    }
+    return {
+        classes: Array.from(classes),
+        defaultClasses: Array.from(defaultClasses),
+    };
+}
+function normalizeVariantRecord(variants) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(variants ?? {})) {
+        if (typeof value === 'string' && /^[A-Za-z0-9_-]+$/.test(value)) {
+            normalized[key] = value;
+        }
+    }
+    return normalized;
+}
+function mergeTailwindConflictClasses(classes) {
+    const result = [];
+    const keyIndexes = new Map();
+    for (const className of classes) {
+        const key = tailwindConflictKey(className);
+        if (key && keyIndexes.has(key)) {
+            result[keyIndexes.get(key)] = className;
+            continue;
+        }
+        if (key) {
+            keyIndexes.set(key, result.length);
+        }
+        result.push(className);
+    }
+    return (0, utils_1.unique)(result);
+}
+function tailwindConflictKey(className) {
+    const segments = className.split(':');
+    const base = segments.pop() ?? className;
+    const prefix = segments.join(':');
+    const keyPrefix = prefix ? `${prefix}|` : '';
+    if (/^-?bg-/.test(base)) {
+        return `${keyPrefix}bg`;
+    }
+    if (/^rounded(?:-|$|\[)/.test(base)) {
+        const side = base.match(/^rounded(?:-([trbl]|tl|tr|br|bl|s|e|ss|se|ee|es))?(?:-|$|\[)/)?.[1];
+        return `${keyPrefix}rounded:${side ?? 'all'}`;
+    }
+    if (/^border-(?:\[[^\]]+\]|transparent|current|black|white|[a-z]+-\d{2,3}|[a-z][a-z0-9-]*)$/.test(base)) {
+        return `${keyPrefix}border-color`;
+    }
+    if (/^text-(?:\[[^\]]+\]|transparent|current|black|white|foreground|muted-foreground|card-foreground|primary-foreground|secondary-foreground|[a-z]+-\d{2,3})$/.test(base)) {
+        return `${keyPrefix}text-color`;
+    }
+    if (/^text-(?:xs|sm|base|lg|xl|[2-9]xl|\[[^\]]+\])$/.test(base)) {
+        return `${keyPrefix}text-size`;
+    }
+    if (/^shadow(?:-|$|\[)/.test(base)) {
+        return `${keyPrefix}shadow`;
+    }
+    return undefined;
+}
 function addEntry(entries, usedKeys, entry) {
     let key = entry.key;
     if (usedKeys.has(key)) {