@promptui-lib/codegen 0.1.4 → 0.1.5

package/dist/detection/component-detector.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Intelligent Component Detector
+ * Detects component types from Figma nodes using multiple strategies:
+ * 1. Fuzzy name matching (multilingual)
+ * 2. Visual property heuristics
+ * 3. Structure-based detection
+ */
+import type { IFigmaNode } from '@promptui-lib/core';
+/**
+ * Detected component type with confidence score
+ */
+export interface IDetectionResult {
+    componentType: string;
+    confidence: number;
+    strategy: 'name' | 'visual' | 'structure' | 'hybrid';
+    details?: string;
+}
+/**
+ * Main detection function - combines all strategies
+ */
+export declare function detectComponentType(node: IFigmaNode): IDetectionResult;
+/**
+ * Detect all components in a tree
+ */
+export declare function detectComponentsInTree(node: IFigmaNode, results?: Map<string, IDetectionResult>): Map<string, IDetectionResult>;
+/**
+ * Get component type with fallback to raw CSS generation
+ */
+export declare function getComponentTypeOrRaw(node: IFigmaNode): {
+    type: 'component' | 'raw';
+    componentType?: string;
+    confidence?: number;
+};
+//# sourceMappingURL=component-detector.d.ts.map

package/dist/detection/component-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-detector.d.ts","sourceRoot":"","sources":["../../src/detection/component-detector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,oBAAoB,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAmgBD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB,CAkEtE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAa,GACjD,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAW/B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG;IACvD,IAAI,EAAE,WAAW,GAAG,KAAK,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAaA"}

package/dist/detection/component-detector.js

@@ -0,0 +1,564 @@
+/**
+ * Intelligent Component Detector
+ * Detects component types from Figma nodes using multiple strategies:
+ * 1. Fuzzy name matching (multilingual)
+ * 2. Visual property heuristics
+ * 3. Structure-based detection
+ */
+/**
+ * Name patterns for fuzzy matching (multilingual)
+ */
+const NAME_PATTERNS = {
+    button: [
+        /button/i, /btn/i, /botão/i, /botao/i, /cta/i, /submit/i, /enviar/i,
+        /action/i, /ação/i, /acao/i, /confirmar/i, /cancelar/i, /salvar/i, /save/i,
+        /click/i, /tap/i, /press/i,
+    ],
+    input: [
+        /input/i, /text.?field/i, /entrada/i, /campo/i, /field/i,
+        /email/i, /password/i, /senha/i, /search/i, /busca/i, /pesquisa/i,
+        /nome/i, /name/i, /telefone/i, /phone/i, /cpf/i, /cnpj/i,
+    ],
+    card: [
+        /card/i, /cartão/i, /cartao/i, /tile/i, /item/i, /panel/i, /painel/i,
+        /box/i, /container/i, /wrapper/i, /bloco/i, /block/i,
+    ],
+    avatar: [
+        /avatar/i, /profile.?pic/i, /user.?image/i, /foto/i, /photo/i,
+        /imagem.?perfil/i, /user.?icon/i,
+    ],
+    checkbox: [
+        /checkbox/i, /check.?box/i, /caixa.?seleção/i, /selecionar/i,
+        /marcar/i, /tick/i,
+    ],
+    radio: [
+        /radio/i, /radio.?button/i, /opção/i, /opcao/i, /option/i,
+    ],
+    switch: [
+        /switch/i, /toggle/i, /alternar/i, /on.?off/i, /liga.?desliga/i,
+    ],
+    select: [
+        /select/i, /dropdown/i, /combo/i, /seleção/i, /selecao/i,
+        /escolher/i, /picker/i, /lista/i, /list/i,
+    ],
+    modal: [
+        /modal/i, /dialog/i, /popup/i, /overlay/i, /alert/i, /alerta/i,
+        /confirm/i, /toast/i, /notification/i, /notificação/i,
+    ],
+    tabs: [
+        /tab/i, /tabs/i, /aba/i, /abas/i, /navigation/i, /nav/i,
+    ],
+    table: [
+        /table/i, /tabela/i, /grid/i, /data.?grid/i, /lista/i, /list/i,
+        /rows/i, /linhas/i,
+    ],
+    icon: [
+        /icon/i, /ícone/i, /icone/i, /symbol/i, /símbolo/i, /simbolo/i,
+        /glyph/i, /svg/i,
+    ],
+    image: [
+        /image/i, /imagem/i, /img/i, /photo/i, /foto/i, /picture/i,
+        /banner/i, /thumb/i, /thumbnail/i,
+    ],
+    text: [
+        /text/i, /texto/i, /label/i, /título/i, /titulo/i, /title/i,
+        /heading/i, /paragraph/i, /parágrafo/i, /paragrafo/i,
+        /description/i, /descrição/i, /descricao/i,
+    ],
+    badge: [
+        /badge/i, /tag/i, /chip/i, /etiqueta/i, /label/i, /status/i,
+        /indicator/i, /indicador/i,
+    ],
+    progress: [
+        /progress/i, /progresso/i, /loading/i, /carregando/i, /spinner/i,
+        /loader/i, /bar/i, /barra/i,
+    ],
+    divider: [
+        /divider/i, /divisor/i, /separator/i, /separador/i, /line/i, /linha/i,
+        /hr/i,
+    ],
+    header: [
+        /header/i, /cabeçalho/i, /cabecalho/i, /topbar/i, /top.?bar/i,
+        /navbar/i, /nav.?bar/i, /app.?bar/i,
+    ],
+    footer: [
+        /footer/i, /rodapé/i, /rodape/i, /bottom/i, /fundo/i,
+    ],
+    sidebar: [
+        /sidebar/i, /side.?bar/i, /menu.?lateral/i, /drawer/i, /nav/i,
+        /navigation/i, /navegação/i, /navegacao/i,
+    ],
+    form: [
+        /form/i, /formulário/i, /formulario/i, /cadastro/i, /registro/i,
+        /register/i, /login/i, /signin/i, /sign.?in/i, /signup/i, /sign.?up/i,
+    ],
+    breadcrumb: [
+        /breadcrumb/i, /migalha/i, /caminho/i, /path/i, /trail/i,
+    ],
+    pagination: [
+        /pagination/i, /paginação/i, /paginacao/i, /page/i, /páginas/i, /paginas/i,
+    ],
+    tooltip: [
+        /tooltip/i, /dica/i, /hint/i, /popover/i, /info/i,
+    ],
+    accordion: [
+        /accordion/i, /collapse/i, /expandir/i, /expand/i, /acordeão/i, /acordeao/i,
+    ],
+    carousel: [
+        /carousel/i, /slider/i, /slideshow/i, /galeria/i, /gallery/i,
+        /swiper/i, /scroll/i,
+    ],
+    rating: [
+        /rating/i, /avaliação/i, /avaliacao/i, /stars/i, /estrelas/i,
+        /review/i, /score/i,
+    ],
+    stepper: [
+        /stepper/i, /steps/i, /wizard/i, /etapas/i, /passos/i,
+    ],
+    menu: [
+        /menu/i, /dropdown.?menu/i, /context.?menu/i, /options/i, /opções/i, /opcoes/i,
+    ],
+    datepicker: [
+        /date/i, /data/i, /calendar/i, /calendário/i, /calendario/i,
+        /picker/i,
+    ],
+    timepicker: [
+        /time/i, /hora/i, /horário/i, /horario/i, /clock/i, /relógio/i, /relogio/i,
+    ],
+    upload: [
+        /upload/i, /file/i, /arquivo/i, /anexo/i, /attachment/i,
+        /drop.?zone/i, /drag/i, /arrastar/i,
+    ],
+};
+const VISUAL_HEURISTICS = {
+    button: {
+        minWidth: 60,
+        maxWidth: 400,
+        minHeight: 28,
+        maxHeight: 80,
+        hasCornerRadius: true,
+        minCornerRadius: 2,
+        hasFill: true,
+        hasText: true,
+        childrenCount: { min: 0, max: 3 },
+    },
+    input: {
+        minWidth: 100,
+        maxWidth: 600,
+        minHeight: 28,
+        maxHeight: 80,
+        hasCornerRadius: true,
+        hasStroke: true,
+        childrenCount: { min: 0, max: 4 },
+    },
+    card: {
+        minWidth: 150,
+        minHeight: 100,
+        hasCornerRadius: true,
+        hasFill: true,
+        hasDropShadow: true,
+        childrenCount: { min: 1, max: 20 },
+    },
+    avatar: {
+        aspectRatio: { min: 0.8, max: 1.2 },
+        minWidth: 24,
+        maxWidth: 200,
+        minCornerRadius: 12, // Usually circular
+        hasFill: true,
+    },
+    checkbox: {
+        minWidth: 14,
+        maxWidth: 32,
+        minHeight: 14,
+        maxHeight: 32,
+        aspectRatio: { min: 0.8, max: 1.2 },
+        hasStroke: true,
+    },
+    switch: {
+        minWidth: 36,
+        maxWidth: 80,
+        minHeight: 16,
+        maxHeight: 40,
+        aspectRatio: { min: 1.5, max: 3 },
+        hasCornerRadius: true,
+        minCornerRadius: 8,
+        hasFill: true,
+    },
+    icon: {
+        minWidth: 12,
+        maxWidth: 64,
+        minHeight: 12,
+        maxHeight: 64,
+        aspectRatio: { min: 0.5, max: 2 },
+        childrenCount: { min: 0, max: 5 },
+    },
+    badge: {
+        minWidth: 16,
+        maxWidth: 120,
+        minHeight: 16,
+        maxHeight: 40,
+        hasCornerRadius: true,
+        minCornerRadius: 4,
+        hasFill: true,
+        hasText: true,
+        childrenCount: { min: 0, max: 2 },
+    },
+    divider: {
+        minWidth: 50,
+        minHeight: 1,
+        maxHeight: 4,
+    },
+    modal: {
+        minWidth: 280,
+        minHeight: 150,
+        hasCornerRadius: true,
+        hasFill: true,
+        hasDropShadow: true,
+        childrenCount: { min: 1, max: 30 },
+    },
+    progress: {
+        minWidth: 80,
+        minHeight: 4,
+        maxHeight: 24,
+        hasCornerRadius: true,
+        hasFill: true,
+    },
+};
+/**
+ * Check if node has a fill
+ */
+function hasFill(node) {
+    if (!node.fills || node.fills.length === 0)
+        return false;
+    return node.fills.some((fill) => fill.type === 'SOLID' || fill.type === 'IMAGE');
+}
+/**
+ * Check if node has a stroke
+ */
+function hasStroke(node) {
+    return !!(node.strokes && node.strokes.length > 0 && node.strokeWeight && node.strokeWeight > 0);
+}
+/**
+ * Check if node has drop shadow
+ */
+function hasDropShadow(node) {
+    if (!node.effects)
+        return false;
+    return node.effects.some((effect) => effect.type === 'DROP_SHADOW' && effect.visible);
+}
+/**
+ * Check if node has text content (direct or in children)
+ */
+function hasText(node) {
+    if (node.type === 'TEXT' && node.characters)
+        return true;
+    if (node.children) {
+        return node.children.some(child => hasText(child));
+    }
+    return false;
+}
+/**
+ * Count direct children
+ */
+function countChildren(node) {
+    return node.children?.length || 0;
+}
+/**
+ * Get node dimensions
+ */
+function getDimensions(node) {
+    if (!node.absoluteBoundingBox)
+        return null;
+    return {
+        width: node.absoluteBoundingBox.width,
+        height: node.absoluteBoundingBox.height,
+    };
+}
+/**
+ * Strategy 1: Fuzzy name matching
+ */
+function detectByName(name) {
+    const normalizedName = name.toLowerCase().trim();
+    for (const [componentType, patterns] of Object.entries(NAME_PATTERNS)) {
+        for (const pattern of patterns) {
+            if (pattern.test(normalizedName)) {
+                // Calculate confidence based on match specificity
+                const matchStr = normalizedName.match(pattern)?.[0] || '';
+                const confidence = matchStr.length / normalizedName.length;
+                return {
+                    componentType,
+                    confidence: Math.min(0.9, 0.5 + confidence * 0.4), // 0.5-0.9 range
+                    strategy: 'name',
+                    details: `Matched pattern: ${pattern.source}`,
+                };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Strategy 2: Visual property heuristics
+ */
+function detectByVisual(node) {
+    const dimensions = getDimensions(node);
+    if (!dimensions)
+        return null;
+    const { width, height } = dimensions;
+    const aspectRatio = width / height;
+    const cornerRadius = node.cornerRadius || 0;
+    const childCount = countChildren(node);
+    const scores = [];
+    for (const [componentType, heuristics] of Object.entries(VISUAL_HEURISTICS)) {
+        let score = 0;
+        let checks = 0;
+        // Width check
+        if (heuristics.minWidth !== undefined) {
+            checks++;
+            if (width >= heuristics.minWidth)
+                score++;
+        }
+        if (heuristics.maxWidth !== undefined) {
+            checks++;
+            if (width <= heuristics.maxWidth)
+                score++;
+        }
+        // Height check
+        if (heuristics.minHeight !== undefined) {
+            checks++;
+            if (height >= heuristics.minHeight)
+                score++;
+        }
+        if (heuristics.maxHeight !== undefined) {
+            checks++;
+            if (height <= heuristics.maxHeight)
+                score++;
+        }
+        // Aspect ratio check
+        if (heuristics.aspectRatio) {
+            checks++;
+            if (aspectRatio >= heuristics.aspectRatio.min && aspectRatio <= heuristics.aspectRatio.max) {
+                score++;
+            }
+        }
+        // Corner radius checks
+        if (heuristics.hasCornerRadius !== undefined) {
+            checks++;
+            if ((cornerRadius > 0) === heuristics.hasCornerRadius)
+                score++;
+        }
+        if (heuristics.minCornerRadius !== undefined) {
+            checks++;
+            if (cornerRadius >= heuristics.minCornerRadius)
+                score++;
+        }
+        if (heuristics.maxCornerRadius !== undefined) {
+            checks++;
+            if (cornerRadius <= heuristics.maxCornerRadius)
+                score++;
+        }
+        // Fill check
+        if (heuristics.hasFill !== undefined) {
+            checks++;
+            if (hasFill(node) === heuristics.hasFill)
+                score++;
+        }
+        // Stroke check
+        if (heuristics.hasStroke !== undefined) {
+            checks++;
+            if (hasStroke(node) === heuristics.hasStroke)
+                score++;
+        }
+        // Drop shadow check
+        if (heuristics.hasDropShadow !== undefined) {
+            checks++;
+            if (hasDropShadow(node) === heuristics.hasDropShadow)
+                score++;
+        }
+        // Text check
+        if (heuristics.hasText !== undefined) {
+            checks++;
+            if (hasText(node) === heuristics.hasText)
+                score++;
+        }
+        // Children count check
+        if (heuristics.childrenCount) {
+            checks++;
+            if (childCount >= heuristics.childrenCount.min && childCount <= heuristics.childrenCount.max) {
+                score++;
+            }
+        }
+        // Layout mode check
+        if (heuristics.layoutMode !== undefined) {
+            checks++;
+            if (node.layoutMode === heuristics.layoutMode)
+                score++;
+        }
+        if (checks > 0) {
+            scores.push({ type: componentType, score: score / checks });
+        }
+    }
+    // Get best match
+    scores.sort((a, b) => b.score - a.score);
+    if (scores.length > 0 && scores[0].score >= 0.5) {
+        return {
+            componentType: scores[0].type,
+            confidence: scores[0].score * 0.8, // Max 0.8 for visual-only
+            strategy: 'visual',
+            details: `Visual score: ${(scores[0].score * 100).toFixed(0)}%`,
+        };
+    }
+    return null;
+}
+/**
+ * Strategy 3: Structure-based detection
+ */
+function detectByStructure(node) {
+    const childCount = countChildren(node);
+    const hasLayout = node.layoutMode && node.layoutMode !== 'NONE';
+    // Form detection: multiple input-like children
+    if (childCount >= 2 && hasLayout && node.layoutMode === 'VERTICAL') {
+        const inputLikeChildren = node.children?.filter(child => {
+            const childDim = getDimensions(child);
+            return childDim && childDim.width > 100 && childDim.height >= 28 && childDim.height <= 60;
+        }) || [];
+        if (inputLikeChildren.length >= 2) {
+            return {
+                componentType: 'form',
+                confidence: 0.6,
+                strategy: 'structure',
+                details: `${inputLikeChildren.length} input-like children in vertical layout`,
+            };
+        }
+    }
+    // Table detection: grid-like structure
+    if (childCount >= 3 && node.layoutMode === 'VERTICAL') {
+        const firstChild = node.children?.[0];
+        if (firstChild?.layoutMode === 'HORIZONTAL' && firstChild.children?.length) {
+            const cellCount = firstChild.children.length;
+            const rowsWithSameCells = node.children?.filter(child => child.layoutMode === 'HORIZONTAL' && child.children?.length === cellCount).length || 0;
+            if (rowsWithSameCells >= 2) {
+                return {
+                    componentType: 'table',
+                    confidence: 0.7,
+                    strategy: 'structure',
+                    details: `Grid-like structure with ${rowsWithSameCells} rows of ${cellCount} cells`,
+                };
+            }
+        }
+    }
+    // Tabs detection: horizontal layout with similar-sized children
+    if (childCount >= 2 && node.layoutMode === 'HORIZONTAL') {
+        const childWidths = node.children?.map(child => getDimensions(child)?.width || 0) || [];
+        const avgWidth = childWidths.reduce((a, b) => a + b, 0) / childWidths.length;
+        const similarWidths = childWidths.every(w => Math.abs(w - avgWidth) < avgWidth * 0.3);
+        if (similarWidths && avgWidth > 50) {
+            return {
+                componentType: 'tabs',
+                confidence: 0.5,
+                strategy: 'structure',
+                details: `${childCount} similarly-sized horizontal items`,
+            };
+        }
+    }
+    // Navigation/menu detection: vertical list with many items
+    if (childCount >= 4 && node.layoutMode === 'VERTICAL') {
+        const textChildren = node.children?.filter(child => hasText(child)).length || 0;
+        if (textChildren >= 3) {
+            return {
+                componentType: 'menu',
+                confidence: 0.5,
+                strategy: 'structure',
+                details: `Vertical list with ${textChildren} text items`,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Main detection function - combines all strategies
+ */
+export function detectComponentType(node) {
+    // Try all strategies
+    const nameResult = detectByName(node.name);
+    const visualResult = detectByVisual(node);
+    const structureResult = detectByStructure(node);
+    // Combine results
+    const results = [nameResult, visualResult, structureResult].filter(Boolean);
+    if (results.length === 0) {
+        // Fallback: use node type
+        if (node.type === 'TEXT') {
+            return {
+                componentType: 'text',
+                confidence: 0.8,
+                strategy: 'visual',
+                details: 'Figma TEXT node',
+            };
+        }
+        // Default to container/div
+        return {
+            componentType: 'container',
+            confidence: 0.3,
+            strategy: 'visual',
+            details: 'No specific component detected',
+        };
+    }
+    // If multiple strategies agree, boost confidence
+    const typeVotes = {};
+    for (const result of results) {
+        if (!typeVotes[result.componentType]) {
+            typeVotes[result.componentType] = { count: 0, totalConfidence: 0, results: [] };
+        }
+        typeVotes[result.componentType].count++;
+        typeVotes[result.componentType].totalConfidence += result.confidence;
+        typeVotes[result.componentType].results.push(result);
+    }
+    // Find best type
+    let bestType = '';
+    let bestScore = 0;
+    for (const [type, data] of Object.entries(typeVotes)) {
+        // Score = average confidence * (1 + 0.2 * agreement bonus)
+        const avgConfidence = data.totalConfidence / data.count;
+        const agreementBonus = (data.count - 1) * 0.2;
+        const score = avgConfidence * (1 + agreementBonus);
+        if (score > bestScore) {
+            bestScore = score;
+            bestType = type;
+        }
+    }
+    const bestData = typeVotes[bestType];
+    const strategies = bestData.results.map(r => r.strategy).join('+');
+    return {
+        componentType: bestType,
+        confidence: Math.min(0.95, bestScore),
+        strategy: bestData.count > 1 ? 'hybrid' : bestData.results[0].strategy,
+        details: `${strategies}: ${bestData.results.map(r => r.details).join('; ')}`,
+    };
+}
+/**
+ * Detect all components in a tree
+ */
+export function detectComponentsInTree(node, results = new Map()) {
+    const detection = detectComponentType(node);
+    results.set(node.id, detection);
+    if (node.children) {
+        for (const child of node.children) {
+            detectComponentsInTree(child, results);
+        }
+    }
+    return results;
+}
+/**
+ * Get component type with fallback to raw CSS generation
+ */
+export function getComponentTypeOrRaw(node) {
+    const result = detectComponentType(node);
+    // If confidence is too low, suggest raw CSS generation
+    if (result.confidence < 0.4) {
+        return { type: 'raw' };
+    }
+    return {
+        type: 'component',
+        componentType: result.componentType,
+        confidence: result.confidence,
+    };
+}

package/dist/detection/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Component Detection Module
+ * Intelligent detection of UI components from Figma nodes
+ */
+export { detectComponentType, detectComponentsInTree, getComponentTypeOrRaw, type IDetectionResult, } from './component-detector.js';
+export { generateRawCSS, cssToInlineStyle, cssToReactStyle, cssToBlock, cssToTailwind, } from './raw-css-generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/detection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detection/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,aAAa,GACd,MAAM,wBAAwB,CAAC"}

package/dist/detection/index.js

@@ -0,0 +1,6 @@
+/**
+ * Component Detection Module
+ * Intelligent detection of UI components from Figma nodes
+ */
+export { detectComponentType, detectComponentsInTree, getComponentTypeOrRaw, } from './component-detector.js';
+export { generateRawCSS, cssToInlineStyle, cssToReactStyle, cssToBlock, cssToTailwind, } from './raw-css-generator.js';

package/dist/detection/raw-css-generator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Raw CSS Generator
+ * Generates pixel-perfect CSS from Figma node properties
+ * Used when no specific component type is detected
+ */
+import type { IFigmaNode } from '@promptui-lib/core';
+/**
+ * Generate all CSS properties from Figma node
+ */
+export declare function generateRawCSS(node: IFigmaNode): Record<string, string>;
+/**
+ * Convert CSS object to inline style string
+ */
+export declare function cssToInlineStyle(css: Record<string, string>): string;
+/**
+ * Convert CSS object to React style object string
+ */
+export declare function cssToReactStyle(css: Record<string, string>): string;
+/**
+ * Convert CSS object to SCSS/CSS block
+ */
+export declare function cssToBlock(css: Record<string, string>, selector: string, indent?: number): string;
+/**
+ * Generate Tailwind classes from CSS (approximation)
+ */
+export declare function cssToTailwind(css: Record<string, string>): string[];
+//# sourceMappingURL=raw-css-generator.d.ts.map

package/dist/detection/raw-css-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-css-generator.d.ts","sourceRoot":"","sources":["../../src/detection/raw-css-generator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,oBAAoB,CAAC;AA4M5F;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0GvE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAQpE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAGnE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,MAAU,GAAG,MAAM,CAQpG;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,CA0InE"}