@schemyx/mcp 0.1.2 → 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)) {
@@ -1641,10 +1823,41 @@ function tailwindDeclarationsForClass(className, styleContext) {
         const [, value] = base.match(/^grid-cols-(\d+)$/) ?? [];
         declarations.push(declaration('grid-template-columns', `repeat(${value}, minmax(0, 1fr))`));
     }
+    if (/^grid-cols-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('grid-template-columns', arbitraryValue(base).replace(/_/g, ' ')));
+    }
     if (/^grid-rows-(\d+)$/.test(base)) {
         const [, value] = base.match(/^grid-rows-(\d+)$/) ?? [];
         declarations.push(declaration('grid-template-rows', `repeat(${value}, minmax(0, 1fr))`));
     }
+    if (/^grid-rows-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('grid-template-rows', arbitraryValue(base).replace(/_/g, ' ')));
+    }
+    if (base === 'auto-rows-fr') {
+        declarations.push(declaration('grid-auto-rows', 'minmax(0, 1fr)'));
+    }
+    if (/^auto-rows-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('grid-auto-rows', arbitraryValue(base).replace(/_/g, ' ')));
+    }
+    if (base === 'flex-row')
+        declarations.push(declaration('flex-direction', 'row'));
+    if (base === 'flex-col')
+        declarations.push(declaration('flex-direction', 'column'));
+    if (base === 'flex-wrap')
+        declarations.push(declaration('flex-wrap', 'wrap'));
+    if (base === 'flex-nowrap')
+        declarations.push(declaration('flex-wrap', 'nowrap'));
+    if (base === 'object-cover')
+        declarations.push(declaration('object-fit', 'cover'));
+    if (base === 'object-contain')
+        declarations.push(declaration('object-fit', 'contain'));
+    if (base === 'object-fill')
+        declarations.push(declaration('object-fit', 'fill'));
+    if (base === 'object-center')
+        declarations.push(declaration('object-position', 'center'));
+    if (/^aspect-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('aspect-ratio', arbitraryValue(base).replace(/_/g, ' ')));
+    }
     if (/^col-span-(\d+)$/.test(base)) {
         const [, value] = base.match(/^col-span-(\d+)$/) ?? [];
         declarations.push(declaration('grid-column', `span ${value} / span ${value}`));
@@ -1876,6 +2089,14 @@ function colorKeywordValue(token) {
     return colors[token];
 }
 function opacityToPercent(value) {
+    const arbitrary = arbitraryTokenValue(value);
+    if (arbitrary) {
+        const numericArbitrary = Number(arbitrary);
+        if (Number.isFinite(numericArbitrary)) {
+            return `${numericArbitrary * 100}%`;
+        }
+        return arbitrary;
+    }
     const numeric = Number(value);
     if (Number.isFinite(numeric)) {
         return `${numeric}%`;
@@ -1904,6 +2125,17 @@ function tailwindNamedSizeValue(token) {
         max: 'max-content',
         fit: 'fit-content',
         prose: '65ch',
+        xs: '20rem',
+        sm: '24rem',
+        md: '28rem',
+        lg: '32rem',
+        xl: '36rem',
+        '2xl': '42rem',
+        '3xl': '48rem',
+        '4xl': '56rem',
+        '5xl': '64rem',
+        '6xl': '72rem',
+        '7xl': '80rem',
     };
     return values[token];
 }
@@ -2391,7 +2623,7 @@ function createUiContract(input) {
         layout: omitEmptyRecord({
             display: filterUiContractClasses(allClasses, (className) => /^(?:flex|inline-flex|grid|inline-grid|block|inline|inline-block|hidden|contents|table)$/.test((0, utils_1.classBase)(className))),
             alignment: filterUiContractClasses(allClasses, (className) => /^(?:items-|justify-|content-|self-|place-)/.test((0, utils_1.classBase)(className))),
-            grid: filterUiContractClasses(allClasses, (className) => /^(?:grid|grid-cols-|col-|row-)/.test((0, utils_1.classBase)(className))),
+            grid: filterUiContractClasses(allClasses, (className) => /^(?:grid|grid-cols-|grid-rows-|auto-rows-|auto-cols-|col-|row-)/.test((0, utils_1.classBase)(className))),
             flex: filterUiContractClasses(allClasses, (className) => /^(?:flex|inline-flex|flex-|basis-|grow|shrink)/.test((0, utils_1.classBase)(className))),
             spacing: grouped.spacing ?? [],
             sizing: grouped.sizing ?? [],