tailwind-unwind 0.2.0 → 0.3.0

package/dist/{chunk-FASYIEVZ.js → chunk-4GXMK3NB.js}

@@ -12,6 +12,9 @@ var KNOWN_ROOT_KEYS = /* @__PURE__ */ new Set([
   "top",
   "dedupeSubsets",
   "dryRun",
+  "prettier",
+  "fromReport",
+  "extractableOnly",
   "analyze",
   "generate",
   "apply"
@@ -24,33 +27,36 @@ var KNOWN_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "prefix",
   "output",
   "dedupeSubsets",
-  "dryRun"
+  "dryRun",
+  "prettier",
+  "fromReport",
+  "extractableOnly"
 ]);
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function assertPositiveNumber(value, path6, errors) {
+function assertPositiveNumber(value, path7, errors) {
   if (value === void 0) {
     return;
   }
   if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
-    errors.push(`${path6} must be a positive number`);
+    errors.push(`${path7} must be a positive number`);
   }
 }
-function assertBoolean(value, path6, errors) {
+function assertBoolean(value, path7, errors) {
   if (value === void 0) {
     return;
   }
   if (typeof value !== "boolean") {
-    errors.push(`${path6} must be a boolean`);
+    errors.push(`${path7} must be a boolean`);
   }
 }
-function assertStringArray(value, path6, errors) {
+function assertStringArray(value, path7, errors) {
   if (value === void 0) {
     return;
   }
   if (!Array.isArray(value) || !value.every((item) => typeof item === "string" && item.length > 0)) {
-    errors.push(`${path6} must be an array of non-empty strings`);
+    errors.push(`${path7} must be an array of non-empty strings`);
   }
 }
 function validateCommandSection(value, section, errors) {
@@ -72,6 +78,11 @@ function validateCommandSection(value, section, errors) {
   assertPositiveNumber(value.top, `${section}.top`, errors);
   assertBoolean(value.dedupeSubsets, `${section}.dedupeSubsets`, errors);
   assertBoolean(value.dryRun, `${section}.dryRun`, errors);
+  assertBoolean(value.prettier, `${section}.prettier`, errors);
+  assertBoolean(value.extractableOnly, `${section}.extractableOnly`, errors);
+  if (value.fromReport !== void 0 && (typeof value.fromReport !== "string" || value.fromReport.length === 0)) {
+    errors.push(`${section}.fromReport must be a non-empty string`);
+  }
   if (value.prefix !== void 0 && (typeof value.prefix !== "string" || value.prefix.length === 0)) {
     errors.push(`${section}.prefix must be a non-empty string`);
   }
@@ -118,6 +129,11 @@ function validateConfigFile(raw, configPath) {
   assertPositiveNumber(source.top, "top", errors);
   assertBoolean(source.dedupeSubsets, "dedupeSubsets", errors);
   assertBoolean(source.dryRun, "dryRun", errors);
+  assertBoolean(source.prettier, "prettier", errors);
+  assertBoolean(source.extractableOnly, "extractableOnly", errors);
+  if (source.fromReport !== void 0 && (typeof source.fromReport !== "string" || source.fromReport.length === 0)) {
+    errors.push("fromReport must be a non-empty string");
+  }
   validateNames(source.names, errors);
   validateCommandSection(source.analyze, "analyze", errors);
   validateCommandSection(source.generate, "generate", errors);
@@ -189,6 +205,15 @@ function pickCommandConfig(source) {
   if (typeof source.dryRun === "boolean") {
     config.dryRun = source.dryRun;
   }
+  if (typeof source.prettier === "boolean") {
+    config.prettier = source.prettier;
+  }
+  if (typeof source.fromReport === "string" && source.fromReport.length > 0) {
+    config.fromReport = source.fromReport;
+  }
+  if (typeof source.extractableOnly === "boolean") {
+    config.extractableOnly = source.extractableOnly;
+  }
   return config;
 }
 function pickNames(source) {
@@ -936,6 +961,113 @@ function calculatePotentialReduction(occurrences, topCombinations) {
   return Math.min(100, Math.round(savable / totalClassUsages * 100));
 }
 
+// src/parser/variantHelpers.ts
+import babelTraverse from "@babel/traverse";
+var VARIANT_CALLEES = /* @__PURE__ */ new Set(["tv", "cva"]);
+function isVariantCallee(expression) {
+  if (expression.type === "Identifier") {
+    return VARIANT_CALLEES.has(expression.name);
+  }
+  if (expression.type === "MemberExpression" && expression.property.type === "Identifier") {
+    return VARIANT_CALLEES.has(expression.property.name);
+  }
+  return false;
+}
+function collectStringsFromObject(node) {
+  const classes = [];
+  for (const prop of node.properties) {
+    if (prop.type === "SpreadElement") {
+      continue;
+    }
+    if (prop.type !== "ObjectProperty") {
+      continue;
+    }
+    collectStringsFromPropertyValue(prop, classes);
+  }
+  return classes;
+}
+function collectStringsFromPropertyValue(prop, classes) {
+  const keyName = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
+  const { value } = prop;
+  if (value.type === "StringLiteral") {
+    classes.push(...splitClassString(value.value));
+    return;
+  }
+  if (value.type === "ObjectExpression") {
+    if (keyName === "variants" || keyName === "compoundVariants") {
+      for (const nested of value.properties) {
+        if (nested.type === "ObjectProperty") {
+          collectStringsFromPropertyValue(nested, classes);
+        }
+      }
+      return;
+    }
+    classes.push(...collectStringsFromObject(value));
+    return;
+  }
+  if (value.type === "ArrayExpression") {
+    for (const element of value.elements) {
+      if (element === null || element.type === "SpreadElement") {
+        continue;
+      }
+      if (element.type === "StringLiteral") {
+        classes.push(...splitClassString(element.value));
+      } else if (element.type === "ObjectExpression") {
+        classes.push(...collectStringsFromObject(element));
+      }
+    }
+  }
+}
+function extractClassesFromVariantCall(call) {
+  const classes = [];
+  for (const arg of call.arguments) {
+    if (arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder") {
+      continue;
+    }
+    if (arg.type === "StringLiteral") {
+      classes.push(...splitClassString(arg.value));
+      continue;
+    }
+    if (arg.type === "ObjectExpression") {
+      classes.push(...collectStringsFromObject(arg));
+    }
+  }
+  return [...new Set(classes)];
+}
+function resolveTraverse(module) {
+  if (typeof module === "function") {
+    return module;
+  }
+  const withDefault = module;
+  if (typeof withDefault.default === "function") {
+    return withDefault.default;
+  }
+  throw new Error("Failed to load @babel/traverse");
+}
+var traverse = resolveTraverse(babelTraverse);
+function collectVariantRegistry(ast) {
+  const registry = /* @__PURE__ */ new Map();
+  traverse(ast, {
+    VariableDeclarator(path7) {
+      registerVariantDeclarator(path7.node, registry);
+    }
+  });
+  return registry;
+}
+function registerVariantDeclarator(declarator, registry) {
+  if (declarator.id.type !== "Identifier" || declarator.init?.type !== "CallExpression") {
+    return;
+  }
+  const { init } = declarator;
+  if (init.callee.type === "V8IntrinsicIdentifier" || !isVariantCallee(init.callee)) {
+    return;
+  }
+  const classes = extractClassesFromVariantCall(init);
+  if (classes.length > 0) {
+    registry.set(declarator.id.name, classes);
+  }
+}
+
 // src/parser/classHelpers.ts
 var CLASS_MERGE_CALLEES = /* @__PURE__ */ new Set([
   "cn",
@@ -978,18 +1110,34 @@ function isClassMergeCallee(expression) {
   }
   return false;
 }
-function extractFromCallArguments(args) {
+function extractFromCallArguments(args, registry) {
   const parts = [];
   for (const arg of args) {
     if (arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder") {
       parts.push({ classes: [], isDynamic: true });
       continue;
     }
-    parts.push(extractClassesFromExpression(arg));
+    parts.push(extractClassesFromExpression(arg, registry));
   }
   return mergeExtractions(parts);
 }
-function extractClassesFromExpression(expression) {
+function extractFromVariantCall(call, registry) {
+  const { callee } = call;
+  if (callee.type !== "V8IntrinsicIdentifier" && isVariantCallee(callee)) {
+    const classes = extractClassesFromVariantCall(call);
+    const hasDynamicArgs = call.arguments.some(
+      (arg) => arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder"
+    );
+    return { classes, isDynamic: hasDynamicArgs };
+  }
+  if (callee.type === "Identifier" && registry?.has(callee.name)) {
+    const classes = registry.get(callee.name) ?? [];
+    const hasArgs = call.arguments.length > 0;
+    return { classes, isDynamic: hasArgs };
+  }
+  return { classes: [], isDynamic: true };
+}
+function extractClassesFromExpression(expression, registry) {
   switch (expression.type) {
     case "StringLiteral":
       return extractFromStringLiteral(expression.value);
@@ -998,40 +1146,44 @@ function extractClassesFromExpression(expression) {
     case "CallExpression": {
       const { callee } = expression;
       if (callee.type !== "V8IntrinsicIdentifier" && isClassMergeCallee(callee)) {
-        return extractFromCallArguments(expression.arguments);
+        return extractFromCallArguments(expression.arguments, registry);
+      }
+      const variantExtraction = extractFromVariantCall(expression, registry);
+      if (variantExtraction.classes.length > 0 || !variantExtraction.isDynamic) {
+        return variantExtraction;
       }
       return { classes: [], isDynamic: true };
     }
     case "ConditionalExpression": {
       const merged = mergeExtractions([
-        extractClassesFromExpression(expression.consequent),
-        extractClassesFromExpression(expression.alternate)
+        extractClassesFromExpression(expression.consequent, registry),
+        extractClassesFromExpression(expression.alternate, registry)
       ]);
       return { ...merged, isDynamic: true };
     }
     case "LogicalExpression": {
       const merged = mergeExtractions([
-        extractClassesFromExpression(expression.left),
-        extractClassesFromExpression(expression.right)
+        extractClassesFromExpression(expression.left, registry),
+        extractClassesFromExpression(expression.right, registry)
       ]);
       return { ...merged, isDynamic: true };
     }
     case "ArrayExpression":
-      return extractFromArrayExpression(expression);
+      return extractFromArrayExpression(expression, registry);
     case "ObjectExpression":
       return extractFromObjectExpression(expression);
     default:
       return { classes: [], isDynamic: true };
   }
 }
-function extractFromArrayExpression(node) {
+function extractFromArrayExpression(node, registry) {
   const parts = [];
   for (const element of node.elements) {
     if (element === null || element.type === "SpreadElement") {
       parts.push({ classes: [], isDynamic: true });
       continue;
     }
-    parts.push(extractClassesFromExpression(element));
+    parts.push(extractClassesFromExpression(element, registry));
   }
   return mergeExtractions(parts);
 }
@@ -1086,7 +1238,7 @@ function isClassAttribute(attr) {
   const name = getAttributeName(attr);
   return name !== null && CLASS_ATTRIBUTES.has(name);
 }
-function extractFromJSXAttribute(attr) {
+function extractFromJSXAttribute(attr, registry) {
   if (!isClassAttribute(attr)) {
     return null;
   }
@@ -1096,7 +1248,7 @@ function extractFromJSXAttribute(attr) {
     return { classes: [], isDynamic: true, line };
   }
   if (value.type === "StringLiteral") {
-    const result = extractClassesFromExpression(value);
+    const result = extractClassesFromExpression(value, registry);
     return { classes: result.classes, isDynamic: result.isDynamic, line };
   }
   if (value.type === "JSXExpressionContainer") {
@@ -1104,7 +1256,7 @@ function extractFromJSXAttribute(attr) {
     if (expr.type === "JSXEmptyExpression") {
       return { classes: [], isDynamic: true, line };
     }
-    const result = extractClassesFromExpression(expr);
+    const result = extractClassesFromExpression(expr, registry);
     return { classes: result.classes, isDynamic: result.isDynamic, line };
   }
   return { classes: [], isDynamic: true, line };
@@ -1121,9 +1273,9 @@ function parseSourceToAst(source) {
 }
 
 // src/parser/jsxParser.ts
-import babelTraverse from "@babel/traverse";
+import babelTraverse2 from "@babel/traverse";
 import fs2 from "fs/promises";
-function resolveTraverse(module) {
+function resolveTraverse2(module) {
   if (typeof module === "function") {
     return module;
   }
@@ -1133,9 +1285,9 @@ function resolveTraverse(module) {
   }
   throw new Error("Failed to load @babel/traverse");
 }
-var traverse = resolveTraverse(babelTraverse);
-function isJSXElementWithClassAttribute(path6) {
-  const opening = path6.node.openingElement;
+var traverse2 = resolveTraverse2(babelTraverse2);
+function isJSXElementWithClassAttribute(path7) {
+  const opening = path7.node.openingElement;
   return opening.attributes.some(
     (attr) => attr.type === "JSXAttribute" && isClassAttribute(attr)
   );
@@ -1143,15 +1295,16 @@ function isJSXElementWithClassAttribute(path6) {
 function collectExtractionsFromAst(ast, filePath) {
   const extractions = [];
   const warnings = [];
-  traverse(ast, {
-    JSXElement(path6) {
-      if (!isJSXElementWithClassAttribute(path6)) {
+  const variantRegistry = collectVariantRegistry(ast);
+  traverse2(ast, {
+    JSXElement(path7) {
+      if (!isJSXElementWithClassAttribute(path7)) {
         return;
       }
-      const opening = path6.node.openingElement;
+      const opening = path7.node.openingElement;
       for (const attr of opening.attributes) {
         if (attr.type !== "JSXAttribute") continue;
-        const extraction = extractFromJSXAttribute(attr);
+        const extraction = extractFromJSXAttribute(attr, variantRegistry);
         if (!extraction) continue;
         if (extraction.isDynamic && extraction.classes.length === 0) {
           const lineInfo = extraction.line ? `:${extraction.line}` : "";
@@ -1467,11 +1620,66 @@ async function analyzeCommand(targetPath, options = {}) {
   return report;
 }
 
+// src/codemod/formatSource.ts
+import { createRequire } from "module";
+import path4 from "path";
+var require2 = createRequire(import.meta.url);
+async function loadPrettier() {
+  try {
+    const prettier = await import("prettier");
+    return prettier;
+  } catch {
+    try {
+      return require2("prettier");
+    } catch {
+      return null;
+    }
+  }
+}
+async function formatSource(source, options) {
+  const prettier = await loadPrettier();
+  if (!prettier) {
+    return { source, formatted: false };
+  }
+  try {
+    const config = await prettier.resolveConfig(options.filePath);
+    const formatted = await prettier.format(source, {
+      ...config,
+      filepath: options.filePath
+    });
+    return { source: formatted, formatted: true };
+  } catch {
+    return { source, formatted: false };
+  }
+}
+async function formatModifiedFiles(files, sources, cwd = process.cwd()) {
+  const formatted = [];
+  const skipped = [];
+  for (const file of files) {
+    const source = sources.get(file);
+    if (!source) {
+      skipped.push(file);
+      continue;
+    }
+    const result = await formatSource(source, {
+      filePath: path4.resolve(cwd, file),
+      cwd
+    });
+    if (result.formatted) {
+      sources.set(file, result.source);
+      formatted.push(file);
+    } else {
+      skipped.push(file);
+    }
+  }
+  return { formatted, skipped };
+}
+
 // src/codemod/replaceClassNames.ts
 import babelGenerate from "@babel/generator";
-import babelTraverse2 from "@babel/traverse";
+import babelTraverse3 from "@babel/traverse";
 import * as t from "@babel/types";
-function resolveTraverse2(module) {
+function resolveTraverse3(module) {
   if (typeof module === "function") {
     return module;
   }
@@ -1491,7 +1699,7 @@ function resolveGenerator(module) {
   }
   throw new Error("Failed to load @babel/generator");
 }
-var traverse2 = resolveTraverse2(babelTraverse2);
+var traverse3 = resolveTraverse3(babelTraverse3);
 var generate = resolveGenerator(babelGenerate);
 function isClassMergeCallee2(expression) {
   if (expression.type === "Identifier") {
@@ -1586,16 +1794,54 @@ function tryReplaceMergeCall(call, replacementMap) {
     partial: true
   };
 }
-function tryReplaceClassAttribute(attr, replacementMap) {
+function tryReplaceTemplateLiteral(attr, replacementMap, registry) {
+  const value = attr.value;
+  if (value?.type !== "JSXExpressionContainer") {
+    return null;
+  }
+  const expression = value.expression;
+  if (expression.type !== "TemplateLiteral" || expression.expressions.length === 0) {
+    return null;
+  }
+  const extracted = extractClassesFromExpression(expression, registry);
+  if (extracted.classes.length === 0) {
+    return null;
+  }
+  const key = normalizeClasses(extracted.classes);
+  const replacement = replacementMap.get(key);
+  if (!replacement) {
+    return null;
+  }
+  const newQuasis = expression.quasis.map((quasi, index) => {
+    if (index !== 0) {
+      return quasi;
+    }
+    const prefix = expression.expressions.length > 0 ? `${replacement} ` : replacement;
+    return t.templateElement(
+      { raw: prefix, cooked: prefix },
+      quasi.tail
+    );
+  });
+  return {
+    expression: t.templateLiteral(newQuasis, [...expression.expressions]),
+    from: key,
+    to: replacement,
+    partial: true
+  };
+}
+function tryReplaceClassAttribute(attr, replacementMap, registry) {
   const value = attr.value;
   if (value?.type !== "JSXExpressionContainer") {
     return null;
   }
   const expression = value.expression;
-  if (expression.type === "JSXEmptyExpression" || !isClassMergeCall(expression)) {
+  if (expression.type === "JSXEmptyExpression") {
     return null;
   }
-  return tryReplaceMergeCall(expression, replacementMap);
+  if (isClassMergeCall(expression)) {
+    return tryReplaceMergeCall(expression, replacementMap);
+  }
+  return tryReplaceTemplateLiteral(attr, replacementMap, registry);
 }
 function replaceClassNamesInSource(source, replacementMap, filePath) {
   const replacements = [];
@@ -1610,16 +1856,21 @@ function replaceClassNamesInSource(source, replacementMap, filePath) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to parse ${filePath}: ${message}`);
   }
-  traverse2(ast, {
-    JSXElement(path6) {
-      const opening = path6.node.openingElement;
+  const variantRegistry = collectVariantRegistry(ast);
+  traverse3(ast, {
+    JSXElement(path7) {
+      const opening = path7.node.openingElement;
       for (const attr of opening.attributes) {
         if (attr.type !== "JSXAttribute" || !isClassAttribute(attr)) {
           continue;
         }
-        const extraction = extractFromJSXAttribute(attr);
+        const extraction = extractFromJSXAttribute(attr, variantRegistry);
         if (!extraction) continue;
-        const mergeReplacement = tryReplaceClassAttribute(attr, replacementMap);
+        const mergeReplacement = tryReplaceClassAttribute(
+          attr,
+          replacementMap,
+          variantRegistry
+        );
         if (mergeReplacement) {
           if (mergeReplacement.expression.type === "StringLiteral") {
             setStringClassAttribute(attr, mergeReplacement.expression.value);
@@ -1775,10 +2026,61 @@ function buildComponents(occurrences, options) {
   }
   return { components, css, replacementMap };
 }
+function buildComponentsFromCombinations(combinations, options) {
+  const { css, components } = generateComponentCss({
+    sourcePath: options.sourcePath,
+    combinations,
+    prefix: options.prefix,
+    names: options.names
+  });
+  const replacementMap = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    const key = [...component.classes].sort().join(" ");
+    replacementMap.set(key, component.className);
+  }
+  return { components, css, replacementMap };
+}
 
-// src/commands/apply.ts
+// src/core/loadAnalyzeReport.ts
 import fs4 from "fs/promises";
-import path4 from "path";
+function isAnalysisReport(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const report = value;
+  return typeof report.targetPath === "string" && typeof report.stats === "object" && Array.isArray(report.stats.topCombinations);
+}
+async function loadExtractableCombinations(reportPath, options = {}) {
+  const raw = await fs4.readFile(reportPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!isAnalysisReport(parsed)) {
+    throw new Error(`Invalid analyze report: ${reportPath}`);
+  }
+  const combinations = parsed.stats.topCombinations.filter(
+    (combo) => options.extractableOnly === false ? true : combo.extractable === true
+  );
+  if (combinations.length === 0) {
+    throw new Error(
+      "No extractable combinations found in report. Re-run analyze or use --extractable-only=false."
+    );
+  }
+  return {
+    targetPath: parsed.targetPath,
+    combinations
+  };
+}
+
+// src/reporters/operationJsonReporter.ts
+function printGenerateJsonReport(report) {
+  console.log(JSON.stringify(report, null, 2));
+}
+function printApplyJsonReport(report) {
+  console.log(JSON.stringify(report, null, 2));
+}
+
+// src/commands/apply.ts
+import fs5 from "fs/promises";
+import path5 from "path";
 import chalk3 from "chalk";
 async function applyCommand(targetPath, options) {
   let scanResult;
@@ -1786,7 +2088,8 @@ async function applyCommand(targetPath, options) {
     scanResult = await scanProject({
       targetPath,
       include: options.include,
-      exclude: options.exclude
+      exclude: options.exclude,
+      extractableMinOccurrences: options.minOccurrences ?? 3
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1794,20 +2097,57 @@ async function applyCommand(targetPath, options) {
     process.exit(1);
   }
   for (const warning of scanResult.warnings) {
-    console.warn(chalk3.yellow(`\u26A0 ${warning}`));
+    if (options.format !== "json") {
+      console.warn(chalk3.yellow(`\u26A0 ${warning}`));
+    }
   }
-  const { components, css, replacementMap } = buildComponents(
-    scanResult.occurrences,
-    {
-      sourcePath: scanResult.resolvedPath,
-      minOccurrences: options.minOccurrences ?? 3,
-      minSize: options.minSize,
-      maxSize: options.maxSize,
-      topLimit: options.top,
-      prefix: options.prefix,
-      names: options.names
+  let components;
+  let css;
+  let replacementMap;
+  try {
+    if (options.fromReport) {
+      const loadedReport = await loadExtractableCombinations(options.fromReport, {
+        extractableOnly: options.extractableOnly ?? true
+      });
+      const built = buildComponentsFromCombinations(loadedReport.combinations, {
+        sourcePath: scanResult.resolvedPath,
+        prefix: options.prefix,
+        names: options.names
+      });
+      components = built.components;
+      css = built.css;
+      replacementMap = built.replacementMap;
+    } else if (options.extractableOnly) {
+      const combinations = scanResult.report.stats.topCombinations.filter(
+        (combo) => combo.extractable
+      );
+      const built = buildComponentsFromCombinations(combinations, {
+        sourcePath: scanResult.resolvedPath,
+        prefix: options.prefix,
+        names: options.names
+      });
+      components = built.components;
+      css = built.css;
+      replacementMap = built.replacementMap;
+    } else {
+      const built = buildComponents(scanResult.occurrences, {
+        sourcePath: scanResult.resolvedPath,
+        minOccurrences: options.minOccurrences ?? 3,
+        minSize: options.minSize,
+        maxSize: options.maxSize,
+        topLimit: options.top,
+        prefix: options.prefix,
+        names: options.names
+      });
+      components = built.components;
+      css = built.css;
+      replacementMap = built.replacementMap;
     }
-  );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(chalk3.red(`Error: ${message}`));
+    process.exit(1);
+  }
   if (components.length === 0) {
     console.error(
       chalk3.yellow(
@@ -1816,31 +2156,71 @@ async function applyCommand(targetPath, options) {
     );
     process.exit(1);
   }
-  const outputPath = path4.resolve(options.output);
+  const outputPath = path5.resolve(options.output);
   let filesModified = 0;
   let replacementsTotal = 0;
   const allReplacements = [];
   const allSkipped = [];
+  const modifiedSources = /* @__PURE__ */ new Map();
+  const modifiedFiles = [];
   for (const file of scanResult.files) {
-    const original = await fs4.readFile(file, "utf-8");
-    const result = replaceClassNamesInSource(
+    const original = await fs5.readFile(file, "utf-8");
+    const result2 = replaceClassNamesInSource(
       original,
       replacementMap,
       file
     );
-    replacementsTotal += result.replacements.length;
-    allReplacements.push(...result.replacements);
-    allSkipped.push(...result.skipped);
-    if (result.changed) {
+    replacementsTotal += result2.replacements.length;
+    allReplacements.push(...result2.replacements);
+    allSkipped.push(...result2.skipped);
+    if (result2.changed) {
       filesModified += 1;
-      if (!options.dryRun) {
-        await fs4.writeFile(file, result.source, "utf-8");
-      }
+      modifiedSources.set(file, result2.source);
+      modifiedFiles.push(file);
     }
   }
+  let prettierFormatted = [];
+  if (!options.dryRun && options.prettier && modifiedFiles.length > 0) {
+    const formatResult = await formatModifiedFiles(
+      modifiedFiles,
+      modifiedSources,
+      process.cwd()
+    );
+    prettierFormatted = formatResult.formatted;
+  }
   if (!options.dryRun) {
-    await fs4.mkdir(path4.dirname(outputPath), { recursive: true });
-    await fs4.writeFile(outputPath, css, "utf-8");
+    for (const file of modifiedFiles) {
+      const source = modifiedSources.get(file);
+      if (source) {
+        await fs5.writeFile(file, source, "utf-8");
+      }
+    }
+    await fs5.mkdir(path5.dirname(outputPath), { recursive: true });
+    await fs5.writeFile(outputPath, css, "utf-8");
+  }
+  const result = {
+    filesModified,
+    replacementsTotal,
+    outputPath,
+    componentsGenerated: components.length,
+    components,
+    replacements: allReplacements,
+    skipped: allSkipped,
+    prettierFormatted
+  };
+  if (options.format === "json") {
+    printApplyJsonReport({
+      command: "apply",
+      dryRun: Boolean(options.dryRun),
+      outputPath,
+      filesModified,
+      replacementsTotal,
+      componentsGenerated: components.length,
+      components,
+      replacements: allReplacements,
+      skipped: allSkipped
+    });
+    return result;
   }
   console.log("");
   if (options.dryRun) {
@@ -1858,6 +2238,11 @@ async function applyCommand(targetPath, options) {
   console.log(
     chalk3.gray(`   Replacements: `) + chalk3.white(String(replacementsTotal))
   );
+  if (prettierFormatted.length > 0) {
+    console.log(
+      chalk3.gray(`   Prettier formatted: `) + chalk3.white(String(prettierFormatted.length))
+    );
+  }
   if (allReplacements.length > 0) {
     console.log("");
     console.log(chalk3.bold("Replacements:"));
@@ -1871,9 +2256,7 @@ async function applyCommand(targetPath, options) {
   }
   if (allSkipped.length > 0) {
     console.log("");
-    console.log(
-      chalk3.bold.yellow(`Skipped (${allSkipped.length}):`)
-    );
+    console.log(chalk3.bold.yellow(`Skipped (${allSkipped.length}):`));
     for (const item of allSkipped) {
       const line = item.line ? `:${item.line}` : "";
       const classes = item.classes.join(" ");
@@ -1886,51 +2269,97 @@ async function applyCommand(targetPath, options) {
   if (!options.dryRun) {
     console.log(
       chalk3.cyan(
-        `Import ${path4.basename(outputPath)} in your global CSS if you haven't already.`
+        `Import ${path5.basename(outputPath)} in your global CSS if you haven't already.`
       )
     );
     console.log("");
   }
-  return {
-    filesModified,
-    replacementsTotal,
-    outputPath,
-    componentsGenerated: components.length
-  };
+  return result;
 }
 
 // src/commands/generate.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 import chalk4 from "chalk";
 async function generateCommand(targetPath, options) {
-  let scanResult;
+  let scanResult = null;
+  let components;
+  let css;
   try {
-    scanResult = await scanProject({
-      targetPath,
-      include: options.include,
-      exclude: options.exclude
-    });
+    if (options.fromReport) {
+      const loadedReport = await loadExtractableCombinations(options.fromReport, {
+        extractableOnly: options.extractableOnly ?? true
+      });
+      const built = buildComponentsFromCombinations(loadedReport.combinations, {
+        sourcePath: loadedReport.targetPath || targetPath,
+        prefix: options.prefix,
+        names: options.names
+      });
+      components = built.components;
+      css = built.css;
+    } else {
+      scanResult = await scanProject({
+        targetPath,
+        include: options.include,
+        exclude: options.exclude,
+        extractableMinOccurrences: options.minOccurrences ?? 3
+      });
+      if (options.extractableOnly) {
+        const combinations = scanResult.report.stats.topCombinations.filter(
+          (combo) => combo.extractable
+        );
+        const built = buildComponentsFromCombinations(combinations, {
+          sourcePath: scanResult.resolvedPath,
+          prefix: options.prefix,
+          names: options.names
+        });
+        components = built.components;
+        css = built.css;
+      } else {
+        const built = buildComponents(scanResult.occurrences, {
+          sourcePath: scanResult.resolvedPath,
+          minOccurrences: options.minOccurrences ?? 3,
+          minSize: options.minSize,
+          maxSize: options.maxSize,
+          topLimit: options.top,
+          prefix: options.prefix,
+          names: options.names
+        });
+        components = built.components;
+        css = built.css;
+      }
+    }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(chalk4.red(`Error: ${message}`));
     process.exit(1);
   }
-  for (const warning of scanResult.warnings) {
-    console.warn(chalk4.yellow(`\u26A0 ${warning}`));
+  if (scanResult) {
+    for (const warning of scanResult.warnings) {
+      if (options.format !== "json") {
+        console.warn(chalk4.yellow(`\u26A0 ${warning}`));
+      }
+    }
+  }
+  const outputPath = path6.resolve(options.output);
+  await fs6.mkdir(path6.dirname(outputPath), { recursive: true });
+  await fs6.writeFile(outputPath, css, "utf-8");
+  const result = {
+    outputPath,
+    componentsGenerated: components.length,
+    components,
+    report: scanResult?.report ?? null
+  };
+  if (options.format === "json") {
+    printGenerateJsonReport({
+      command: "generate",
+      outputPath,
+      componentsGenerated: components.length,
+      components,
+      cssWritten: true
+    });
+    return result;
   }
-  const { css, components } = buildComponents(scanResult.occurrences, {
-    sourcePath: scanResult.resolvedPath,
-    minOccurrences: options.minOccurrences ?? 3,
-    minSize: options.minSize,
-    maxSize: options.maxSize,
-    topLimit: options.top,
-    prefix: options.prefix,
-    names: options.names
-  });
-  const outputPath = path5.resolve(options.output);
-  await fs5.mkdir(path5.dirname(outputPath), { recursive: true });
-  await fs5.writeFile(outputPath, css, "utf-8");
   console.log("");
   console.log(chalk4.bold.green("\u2705 CSS generated successfully"));
   console.log(chalk4.gray(`   Output: `) + chalk4.white(outputPath));
@@ -1959,11 +2388,7 @@ async function generateCommand(targetPath, options) {
     );
   }
   console.log("");
-  return {
-    outputPath,
-    componentsGenerated: components.length,
-    report: scanResult.report
-  };
+  return result;
 }
 
 export {
@@ -1979,6 +2404,10 @@ export {
   findFrequentPatterns,
   findRepeatedClassSets,
   calculatePotentialReduction,
+  VARIANT_CALLEES,
+  isVariantCallee,
+  extractClassesFromVariantCall,
+  collectVariantRegistry,
   CLASS_MERGE_CALLEES,
   extractClassesFromExpression,
   isClassAttribute,
@@ -1993,6 +2422,8 @@ export {
   printConsoleReport,
   printJsonReport,
   analyzeCommand,
+  formatSource,
+  formatModifiedFiles,
   replaceClassNamesInSource,
   DEFAULT_CLASS_PREFIX,
   normalizeClassPrefix,
@@ -2000,7 +2431,11 @@ export {
   assignComponentClassNames,
   generateComponentCss,
   buildComponents,
+  buildComponentsFromCombinations,
+  loadExtractableCombinations,
+  printGenerateJsonReport,
+  printApplyJsonReport,
   applyCommand,
   generateCommand
 };
-//# sourceMappingURL=chunk-FASYIEVZ.js.map
+//# sourceMappingURL=chunk-4GXMK3NB.js.map