cleanwind 0.1.3 → 0.3.0

package/README.md

@@ -4,7 +4,8 @@ Clean imports and Tailwind CSS class names from the command line.
 
 `cleanwind` removes duplicate import specifiers, merges imports from the same
 module, sorts import groups, deduplicates Tailwind CSS classes, sorts utilities,
-and reports conflicting classes.
+reports conflicting classes, cleans static class strings in common helper calls,
+and can format changed files with Prettier.
 
 ## Installation
 
@@ -20,6 +21,7 @@ For a local project install, run cleanwind through your package manager:
 npx cleanwind check
 npx cleanwind fix
 npx cleanwind fix --staged
+npx cleanwind fix --format
 ```
 
 Or with npm/pnpm/yarn/bun:
@@ -62,10 +64,12 @@ npx cleanwind check --cwd ./apps/web
 npx cleanwind check --config ./cleanwind.config.ts
 npx cleanwind check --write
 npx cleanwind check --verbose
+npx cleanwind check --format
 
 npx cleanwind fix
 npx cleanwind fix --staged
 npx cleanwind fix --check
+npx cleanwind fix --format
 npx cleanwind fix --cwd ./apps/web --verbose
 ```
 
@@ -73,3 +77,29 @@ npx cleanwind fix --cwd ./apps/web --verbose
 
 The published CLI bundles the cleanwind core engine, so installing `cleanwind`
 does not require a separate core package.
+
+## Configuration
+
+```ts
+export default {
+  imports: true,
+  tailwind: true,
+  removeDuplicateImports: true,
+  removeUnusedImports: false,
+  removeDuplicateClasses: true,
+  sortImports: true,
+  importAliases: ["@/"],
+  sortTailwindClasses: true,
+  tailwindFunctions: ["clsx", "classnames", "cva", "cn", "twMerge"],
+  detectConflicts: true,
+  format: false
+};
+```
+
+Use `removeUnusedImports: true` only when you want cleanwind to remove import
+specifiers that appear unused. Use `format: "prettier"` or `--format` to format
+output with Prettier after cleanup.
+
+Use `importAliases` for project aliases such as `@/`, `~/`, or `~app/`. Use
+`tailwindFunctions` to control which helper calls cleanwind scans for static
+class strings.

package/dist/index.js

@@ -7,14 +7,15 @@ import { Command } from "commander";
 import { existsSync } from "fs";
 import path from "path";
 import { createJiti } from "jiti";
-import * as t2 from "@babel/types";
+import * as t from "@babel/types";
 import MagicString from "magic-string";
 import { parse } from "@babel/parser";
-import * as t from "@babel/types";
 import * as t3 from "@babel/types";
 import MagicString2 from "magic-string";
+import * as t2 from "@babel/types";
 import { promises as fs } from "fs";
 import path3 from "path";
+import * as prettier from "prettier";
 import { execFileSync } from "child_process";
 import path2 from "path";
 import fg from "fast-glob";
@@ -22,10 +23,14 @@ var defaultConfig = {
   imports: true,
   tailwind: true,
   removeDuplicateImports: true,
+  removeUnusedImports: false,
   removeDuplicateClasses: true,
   sortImports: true,
+  importAliases: ["@/"],
   sortTailwindClasses: true,
+  tailwindFunctions: ["clsx", "classnames", "cva", "cn", "twMerge"],
   detectConflicts: true,
+  format: false,
   include: ["src/**/*.{js,jsx,ts,tsx}"],
   exclude: ["node_modules", ".next", "dist"]
 };
@@ -77,26 +82,6 @@ function parseSource(source) {
   });
 }
 var visitorKeys = t.VISITOR_KEYS;
-function walkNode(node, enter, parent) {
-  enter(node, parent);
-  const keys = visitorKeys[node.type] ?? [];
-  const record = node;
-  for (const key of keys) {
-    const value = record[key];
-    if (Array.isArray(value)) {
-      for (const child of value) {
-        if (isNode(child)) {
-          walkNode(child, enter, node);
-        }
-      }
-    } else if (isNode(value)) {
-      walkNode(value, enter, node);
-    }
-  }
-}
-function isNode(value) {
-  return typeof value === "object" && value !== null && "type" in value;
-}
 var ImportCleaner = class {
   /** Checks whether imports would change after cleanwind normalization. */
   static check(context) {
@@ -115,105 +100,277 @@ var ImportCleaner = class {
   /** Returns source text with unused, duplicated, and unordered imports normalized. */
   static fix(context) {
     const ast = parseSource(context.source);
-    const imports = ast.program.body.filter(t2.isImportDeclaration);
+    const imports = ast.program.body.filter(t.isImportDeclaration);
     if (imports.length === 0) {
       return { output: context.source, issues: [] };
     }
-    const usedIdentifiers = collectUsedIdentifiers(ast);
-    const records = buildImportRecords(imports, usedIdentifiers, context.config.sortImports);
+    const usedIdentifiers = context.config.removeUnusedImports ? collectUsedImportIdentifiers(ast) : void 0;
+    const records = buildImportRecords(imports, usedIdentifiers, {
+      mergeDuplicates: context.config.removeDuplicateImports,
+      sortImports: context.config.sortImports,
+      importAliases: context.config.importAliases
+    });
     const spans = imports.map((declaration) => spanForImport(context.source, declaration));
     const output = replaceImports(context.source, spans, renderImportBlock(records));
     return { output, issues: [] };
   }
 };
-function collectUsedIdentifiers(ast) {
-  const identifiers = /* @__PURE__ */ new Set();
+function collectUsedImportIdentifiers(ast) {
+  const used = /* @__PURE__ */ new Set();
+  const programScope = createScope();
   for (const statement of ast.program.body) {
-    if (t2.isImportDeclaration(statement)) {
+    if (!t.isImportDeclaration(statement)) {
       continue;
     }
-    walkNode(statement, (node, parent) => {
-      if (t2.isIdentifier(node) && isIdentifierReference(parent, node)) {
-        identifiers.add(node.name);
-      }
-      if (t2.isJSXIdentifier(node) && isJSXIdentifierReference(parent, node)) {
-        identifiers.add(node.name);
-      }
-    });
+    for (const specifier of statement.specifiers) {
+      programScope.bindings.set(specifier.local.name, "import");
+    }
+  }
+  for (const statement of ast.program.body) {
+    if (t.isImportDeclaration(statement)) {
+      continue;
+    }
+    collectHoistedBindings(statement, programScope);
+    walkUsage(statement, void 0, [programScope], used);
   }
-  return identifiers;
+  return used;
 }
 function isIdentifierReference(parent, node) {
   if (!parent) {
     return true;
   }
-  if (t2.isVariableDeclarator(parent) && parent.id === node) return false;
-  if ((t2.isFunctionDeclaration(parent) || t2.isFunctionExpression(parent)) && parent.id === node)
+  if (t.isVariableDeclarator(parent) && parent.id === node) return false;
+  if ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent)) && parent.id === node)
     return false;
-  if ((t2.isClassDeclaration(parent) || t2.isClassExpression(parent)) && parent.id === node)
+  if ((t.isClassDeclaration(parent) || t.isClassExpression(parent)) && parent.id === node)
     return false;
-  if (t2.isObjectProperty(parent) && parent.key === node && !parent.computed) return false;
-  if (t2.isObjectMethod(parent) && parent.key === node && !parent.computed) return false;
-  if (t2.isMemberExpression(parent) && parent.property === node && !parent.computed) return false;
-  if (t2.isLabeledStatement(parent) && parent.label === node) return false;
-  if (t2.isTSTypeAliasDeclaration(parent) && parent.id === node) return false;
-  if (t2.isTSInterfaceDeclaration(parent) && parent.id === node) return false;
+  if (t.isObjectProperty(parent) && parent.key === node && !parent.computed) return false;
+  if (t.isObjectMethod(parent) && parent.key === node && !parent.computed) return false;
+  if (t.isMemberExpression(parent) && parent.property === node && !parent.computed) return false;
+  if (t.isLabeledStatement(parent) && parent.label === node) return false;
+  if (t.isTSTypeAliasDeclaration(parent) && parent.id === node) return false;
+  if (t.isTSInterfaceDeclaration(parent) && parent.id === node) return false;
   return true;
 }
 function isJSXIdentifierReference(parent, node) {
   if (!parent) {
     return false;
   }
-  if (t2.isJSXAttribute(parent)) {
+  if (t.isJSXAttribute(parent)) {
     return false;
   }
-  return t2.isJSXOpeningElement(parent) && parent.name === node || t2.isJSXClosingElement(parent) && parent.name === node || t2.isJSXMemberExpression(parent) && parent.object === node;
+  return t.isJSXOpeningElement(parent) && parent.name === node || t.isJSXClosingElement(parent) && parent.name === node || t.isJSXMemberExpression(parent) && parent.object === node;
+}
+function walkUsage(node, parent, scopes, used) {
+  if (t.isImportDeclaration(node)) {
+    return;
+  }
+  if (t.isFunctionDeclaration(node)) {
+    declareIdentifier(node.id, currentScope(scopes));
+    const functionScope = createChildScope();
+    declarePatterns(node.params, functionScope);
+    if (node.body) {
+      walkUsage(node.body, node, [...scopes, functionScope], used);
+    }
+    return;
+  }
+  if (t.isFunctionExpression(node) || t.isArrowFunctionExpression(node)) {
+    const functionScope = createChildScope();
+    if (t.isFunctionExpression(node)) {
+      declareIdentifier(node.id, functionScope);
+    }
+    declarePatterns(node.params, functionScope);
+    walkChildren(node, parent, [...scopes, functionScope], used, /* @__PURE__ */ new Set(["id", "params"]));
+    return;
+  }
+  if (t.isBlockStatement(node) || t.isProgram(node)) {
+    const blockScope = t.isProgram(node) ? currentScope(scopes) : createChildScope();
+    collectHoistedBindings(node, blockScope);
+    const nextScopes = t.isProgram(node) ? scopes : [...scopes, blockScope];
+    walkChildren(node, parent, nextScopes, used);
+    return;
+  }
+  if (t.isVariableDeclarator(node)) {
+    declarePattern(node.id, currentScope(scopes));
+    if (node.init) {
+      walkUsage(node.init, node, scopes, used);
+    }
+    return;
+  }
+  if (t.isClassDeclaration(node)) {
+    declareIdentifier(node.id, currentScope(scopes));
+    walkChildren(node, parent, scopes, used, /* @__PURE__ */ new Set(["id"]));
+    return;
+  }
+  if (t.isCatchClause(node)) {
+    const catchScope = createChildScope();
+    if (node.param) {
+      declarePattern(node.param, catchScope);
+    }
+    walkUsage(node.body, node, [...scopes, catchScope], used);
+    return;
+  }
+  if (t.isTSTypeAliasDeclaration(node) || t.isTSInterfaceDeclaration(node)) {
+    declareIdentifier(node.id, currentScope(scopes));
+    walkChildren(node, parent, scopes, used, /* @__PURE__ */ new Set(["id"]));
+    return;
+  }
+  if (t.isIdentifier(node) && isIdentifierReference(parent, node) && resolvesToImport(node.name, scopes)) {
+    used.add(node.name);
+  }
+  if (t.isJSXIdentifier(node) && isJSXIdentifierReference(parent, node) && resolvesToImport(node.name, scopes)) {
+    used.add(node.name);
+  }
+  walkChildren(node, parent, scopes, used);
 }
-function buildImportRecords(declarations, usedIdentifiers, sort) {
+function walkChildren(node, parent, scopes, used, skipKeys = /* @__PURE__ */ new Set()) {
+  const keys = visitorKeys[node.type] ?? [];
+  const record = node;
+  for (const key of keys) {
+    if (skipKeys.has(key)) {
+      continue;
+    }
+    const value = record[key];
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (isNode(child)) {
+          walkUsage(child, node, scopes, used);
+        }
+      }
+    } else if (isNode(value)) {
+      walkUsage(value, node, scopes, used);
+    }
+  }
+}
+function collectHoistedBindings(node, scope) {
+  const body = t.isProgram(node) || t.isBlockStatement(node) ? node.body : [node];
+  for (const statement of body) {
+    if (t.isFunctionDeclaration(statement)) {
+      declareIdentifier(statement.id, scope);
+    } else if (t.isClassDeclaration(statement)) {
+      declareIdentifier(statement.id, scope);
+    } else if (t.isVariableDeclaration(statement)) {
+      for (const declaration of statement.declarations) {
+        declarePattern(declaration.id, scope);
+      }
+    } else if (t.isTSTypeAliasDeclaration(statement) || t.isTSInterfaceDeclaration(statement)) {
+      declareIdentifier(statement.id, scope);
+    }
+  }
+}
+function createScope() {
+  return { bindings: /* @__PURE__ */ new Map() };
+}
+function createChildScope() {
+  return createScope();
+}
+function currentScope(scopes) {
+  return scopes[scopes.length - 1] ?? createScope();
+}
+function declareIdentifier(node, scope) {
+  if (node) {
+    scope.bindings.set(node.name, "local");
+  }
+}
+function declarePatterns(patterns, scope) {
+  for (const pattern of patterns) {
+    declarePattern(pattern, scope);
+  }
+}
+function declarePattern(pattern, scope) {
+  if (t.isIdentifier(pattern)) {
+    scope.bindings.set(pattern.name, "local");
+  } else if (t.isTSParameterProperty(pattern)) {
+    declarePattern(pattern.parameter, scope);
+  } else if (t.isRestElement(pattern)) {
+    declarePattern(pattern.argument, scope);
+  } else if (t.isAssignmentPattern(pattern)) {
+    declarePattern(pattern.left, scope);
+  } else if (t.isObjectPattern(pattern)) {
+    for (const property of pattern.properties) {
+      if (t.isObjectProperty(property)) {
+        declarePattern(property.value, scope);
+      } else if (t.isRestElement(property)) {
+        declarePattern(property.argument, scope);
+      }
+    }
+  } else if (t.isArrayPattern(pattern)) {
+    for (const element of pattern.elements) {
+      if (element) {
+        declarePattern(element, scope);
+      }
+    }
+  }
+}
+function resolvesToImport(name, scopes) {
+  for (let index = scopes.length - 1; index >= 0; index -= 1) {
+    const binding = scopes[index]?.bindings.get(name);
+    if (binding) {
+      return binding === "import";
+    }
+  }
+  return false;
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function buildImportRecords(declarations, usedIdentifiers, options) {
   const records = /* @__PURE__ */ new Map();
-  const sideEffects = [];
-  for (const declaration of declarations) {
+  const orderedRecords = [];
+  let sideEffectChunk = 0;
+  declarations.forEach((declaration, order) => {
     const source = declaration.source.value;
     const sideEffect = declaration.specifiers.length === 0;
     if (sideEffect) {
-      sideEffects.push({
+      orderedRecords.push({
+        key: `side-effect:${order}`,
         source,
         named: [],
         sideEffect: true,
-        group: classifyImport(source)
+        group: classifyImport(source, options.importAliases),
+        order
       });
-      continue;
+      sideEffectChunk += 1;
+      return;
     }
-    const key = source;
+    const key = options.mergeDuplicates ? `${sideEffectChunk}:${source}` : `${order}:${source}`;
     const record = records.get(key) ?? {
       source,
+      key,
       named: [],
       sideEffect: false,
-      group: classifyImport(source)
+      group: classifyImport(source, options.importAliases),
+      order
     };
     for (const specifier of declaration.specifiers) {
       const local = specifier.local.name;
-      if (!usedIdentifiers.has(local)) {
+      if (usedIdentifiers && !usedIdentifiers.has(local)) {
         continue;
       }
-      if (t2.isImportDefaultSpecifier(specifier)) {
+      if (t.isImportDefaultSpecifier(specifier)) {
         record.defaultName ??= local;
-      } else if (t2.isImportNamespaceSpecifier(specifier)) {
+      } else if (t.isImportNamespaceSpecifier(specifier)) {
         record.namespaceName ??= local;
-      } else if (t2.isImportSpecifier(specifier)) {
+      } else if (t.isImportSpecifier(specifier)) {
         const declarationKind = declaration.importKind === "type" ? "type" : "value";
         record.named.push(importPartFromSpecifier(specifier, declarationKind));
       }
     }
     if (record.defaultName || record.namespaceName || record.named.length > 0) {
-      records.set(key, dedupeRecord(record));
+      const nextRecord = options.mergeDuplicates ? dedupeRecord(record) : record;
+      records.set(key, nextRecord);
+      const existingIndex = orderedRecords.findIndex((item) => item.key === key);
+      if (existingIndex >= 0) {
+        orderedRecords[existingIndex] = nextRecord;
+      } else {
+        orderedRecords.push(nextRecord);
+      }
     }
-  }
-  const merged = [...records.values(), ...sideEffects];
-  return sort ? sortRecords(merged) : merged;
+  });
+  return options.sortImports ? sortRecords(orderedRecords) : orderedRecords;
 }
 function importPartFromSpecifier(specifier, declarationKind) {
-  const imported = t2.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+  const imported = t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
   return {
     imported,
     local: specifier.local.name,
@@ -236,20 +393,37 @@ function sortRecords(records) {
     alias: 1,
     relative: 2
   };
-  return [...records].sort((left, right) => {
-    const groupDelta = groupRank[left.group] - groupRank[right.group];
-    if (groupDelta !== 0) {
-      return groupDelta;
-    }
-    const sideEffectDelta = Number(left.sideEffect) - Number(right.sideEffect);
-    if (sideEffectDelta !== 0) {
-      return sideEffectDelta;
+  const sorted = [];
+  let chunk = [];
+  const flushChunk = () => {
+    sorted.push(
+      ...chunk.sort((left, right) => {
+        const groupDelta = groupRank[left.group] - groupRank[right.group];
+        if (groupDelta !== 0) {
+          return groupDelta;
+        }
+        const sourceDelta = left.source.localeCompare(right.source);
+        if (sourceDelta !== 0) {
+          return sourceDelta;
+        }
+        return left.order - right.order;
+      })
+    );
+    chunk = [];
+  };
+  for (const record of records.sort((left, right) => left.order - right.order)) {
+    if (record.sideEffect) {
+      flushChunk();
+      sorted.push(record);
+      continue;
     }
-    return left.source.localeCompare(right.source);
-  });
+    chunk.push(record);
+  }
+  flushChunk();
+  return sorted;
 }
-function classifyImport(source) {
-  if (source.startsWith("@/")) {
+function classifyImport(source, importAliases) {
+  if (importAliases.some((alias) => source.startsWith(alias))) {
     return "alias";
   }
   if (source.startsWith(".")) {
@@ -258,11 +432,23 @@ function classifyImport(source) {
   return "package";
 }
 function renderImportBlock(records) {
-  const groups = ["package", "alias", "relative"];
-  const renderedGroups = groups.map((group) => records.filter((record) => record.group === group).map(renderImportRecord)).filter((group) => group.length > 0).map((group) => group.join("\n"));
-  return renderedGroups.length > 0 ? `${renderedGroups.join("\n\n")}
+  if (records.length === 0) {
+    return "";
+  }
+  const rendered = [];
+  records.forEach((record, index) => {
+    const previous = records[index - 1];
+    if (previous && shouldSeparateImports(previous, record)) {
+      rendered.push("");
+    }
+    rendered.push(renderImportRecord(record));
+  });
+  return `${rendered.join("\n")}
 
-` : "";
+`;
+}
+function shouldSeparateImports(left, right) {
+  return left.sideEffect || right.sideEffect || left.group !== right.group;
 }
 function renderImportRecord(record) {
   if (record.sideEffect) {
@@ -303,6 +489,27 @@ function replaceImports(source, spans, importBlock) {
   magic.appendLeft(firstStart, importBlock);
   return magic.toString().replace(/^\n+/u, "");
 }
+var visitorKeys2 = t2.VISITOR_KEYS;
+function walkNode(node, enter, parent) {
+  enter(node, parent);
+  const keys = visitorKeys2[node.type] ?? [];
+  const record = node;
+  for (const key of keys) {
+    const value = record[key];
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (isNode2(child)) {
+          walkNode(child, enter, node);
+        }
+      }
+    } else if (isNode2(value)) {
+      walkNode(value, enter, node);
+    }
+  }
+}
+function isNode2(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
 var displayClasses = /* @__PURE__ */ new Set([
   "block",
   "inline-block",
@@ -315,9 +522,42 @@ var displayClasses = /* @__PURE__ */ new Set([
   "hidden"
 ]);
 var positionClasses = /* @__PURE__ */ new Set(["static", "fixed", "absolute", "relative", "sticky"]);
-function normalizeClassList(value, sortClasses) {
-  const unique = [...new Set(splitClasses(value))];
-  const classes = sortClasses ? unique.sort(compareTailwindClasses) : unique;
+var variantOrder = [
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "2xl",
+  "dark",
+  "motion-safe",
+  "motion-reduce",
+  "portrait",
+  "landscape",
+  "first",
+  "last",
+  "odd",
+  "even",
+  "visited",
+  "checked",
+  "empty",
+  "enabled",
+  "disabled",
+  "group-hover",
+  "group-focus",
+  "peer-hover",
+  "peer-focus",
+  "hover",
+  "focus",
+  "focus-within",
+  "focus-visible",
+  "active",
+  "invalid",
+  "placeholder-shown"
+];
+function normalizeClassList(value, options) {
+  const parsed = splitClasses(value);
+  const deduped = options.removeDuplicates ? [...new Set(parsed)] : parsed;
+  const classes = options.sortClasses ? [...deduped].sort(compareTailwindClasses) : deduped;
   return classes.join(" ");
 }
 function splitClasses(value) {
@@ -326,7 +566,7 @@ function splitClasses(value) {
 function compareTailwindClasses(left, right) {
   const leftClass = classifyClass(left);
   const rightClass = classifyClass(right);
-  const variantDelta = leftClass.variant.localeCompare(rightClass.variant);
+  const variantDelta = compareVariants(leftClass.variant, rightClass.variant);
   if (variantDelta !== 0) {
     return variantDelta;
   }
@@ -346,16 +586,52 @@ function conflictKey(className) {
   if (positionClasses.has(utility)) {
     return `${variantPrefix}position`;
   }
+  if (/^-?z-/u.test(utility)) {
+    return `${variantPrefix}z-index`;
+  }
+  if (utility.startsWith("overflow-")) {
+    return `${variantPrefix}${utility.startsWith("overflow-x-") ? "overflow-x" : utility.startsWith("overflow-y-") ? "overflow-y" : "overflow"}`;
+  }
   const spacing = spacingConflictKey(utility);
   if (spacing) {
     return `${variantPrefix}${spacing}`;
   }
+  if (/^(w|h|min-w|min-h|max-w|max-h)-/u.test(utility)) {
+    return `${variantPrefix}${utility.split("-").slice(0, utility.startsWith("min-") || utility.startsWith("max-") ? 2 : 1).join("-")}`;
+  }
   if (/^text-(xs|sm|base|lg|xl|[2-9]xl)$/u.test(utility)) {
     return `${variantPrefix}font-size`;
   }
+  if (/^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/u.test(utility)) {
+    return `${variantPrefix}font-weight`;
+  }
+  if (/^leading-/u.test(utility)) {
+    return `${variantPrefix}line-height`;
+  }
   if (utility.startsWith("bg-")) {
     return `${variantPrefix}background-color`;
   }
+  if (utility.startsWith("rounded")) {
+    return `${variantPrefix}${roundedConflictKey(utility)}`;
+  }
+  if (/^border(?:-[trblxy])?-/u.test(utility) || utility === "border") {
+    return `${variantPrefix}${borderConflictKey(utility)}`;
+  }
+  if (/^flex-(row|row-reverse|col|col-reverse)$/u.test(utility)) {
+    return `${variantPrefix}flex-direction`;
+  }
+  if (/^flex-(wrap|wrap-reverse|nowrap)$/u.test(utility)) {
+    return `${variantPrefix}flex-wrap`;
+  }
+  if (/^grid-cols-/u.test(utility)) {
+    return `${variantPrefix}grid-template-columns`;
+  }
+  if (/^grid-rows-/u.test(utility)) {
+    return `${variantPrefix}grid-template-rows`;
+  }
+  if (/^gap[xy]?-/u.test(utility)) {
+    return `${variantPrefix}${utility.startsWith("gap-x-") ? "gap-x" : utility.startsWith("gap-y-") ? "gap-y" : "gap"}`;
+  }
   return void 0;
 }
 function spacingConflictKey(utility) {
@@ -396,6 +672,39 @@ function splitVariant(className) {
 function stripImportant(utility) {
   return utility.startsWith("!") ? utility.slice(1) : utility;
 }
+function compareVariants(left, right) {
+  const leftParts = left ? left.split(":") : [];
+  const rightParts = right ? right.split(":") : [];
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = leftParts[index] ?? "";
+    const rightPart = rightParts[index] ?? "";
+    const delta = variantRank(leftPart) - variantRank(rightPart);
+    if (delta !== 0) {
+      return delta;
+    }
+    const lexical = leftPart.localeCompare(rightPart);
+    if (lexical !== 0) {
+      return lexical;
+    }
+  }
+  return 0;
+}
+function variantRank(variant) {
+  if (!variant) {
+    return -1;
+  }
+  const index = variantOrder.indexOf(variant);
+  return index >= 0 ? index : 1e3;
+}
+function roundedConflictKey(utility) {
+  const match = /^rounded(?:-(?<side>[trbl]|tl|tr|br|bl))?-/u.exec(utility);
+  return match?.groups?.side ? `border-radius-${match.groups.side}` : "border-radius";
+}
+function borderConflictKey(utility) {
+  const match = /^border(?:-(?<side>[trblxy]))?(?:-|$)/u.exec(utility);
+  return match?.groups?.side ? `border-${match.groups.side}` : "border";
+}
 function rankUtility(utility) {
   if (utility.startsWith("container")) return 0;
   if (positionClasses.has(utility) || utility.startsWith("inset-")) return 10;
@@ -436,11 +745,14 @@ var TailwindCleaner = class {
   /** Returns source text with duplicated and unordered Tailwind classes normalized. */
   static fix(context) {
     const ast = parseSource(context.source);
-    const segments = collectClassSegments(ast);
+    const segments = collectClassSegments(ast, context.config.tailwindFunctions);
     const magic = new MagicString2(context.source);
     const conflicts = [];
     for (const segment of segments) {
-      const nextValue = normalizeClassList(segment.value, context.config.sortTailwindClasses);
+      const nextValue = normalizeClassList(segment.value, {
+        removeDuplicates: context.config.removeDuplicateClasses,
+        sortClasses: context.config.sortTailwindClasses
+      });
       if (nextValue !== segment.value) {
         magic.overwrite(segment.start, segment.end, nextValue);
       }
@@ -462,8 +774,9 @@ var TailwindCleaner = class {
     };
   }
 };
-function collectClassSegments(ast) {
+function collectClassSegments(ast, tailwindFunctions) {
   const segments = [];
+  const functionNames = new Set(tailwindFunctions);
   walkNode(ast, (node) => {
     if (t3.isJSXAttribute(node)) {
       if (!isClassAttribute(node)) {
@@ -480,6 +793,8 @@ function collectClassSegments(ast) {
           segments.push(segmentFromTemplateElement(quasi));
         }
       }
+    } else if (t3.isCallExpression(node) && isTailwindFunctionCall(node, functionNames)) {
+      collectCallExpressionSegments(node, segments);
     }
   });
   return segments;
@@ -507,6 +822,74 @@ function segmentFromTemplateElement(node) {
     line: node.loc?.start.line ?? 1
   };
 }
+function collectCallExpressionSegments(node, segments) {
+  for (const argument of node.arguments) {
+    collectExpressionSegments(argument, segments);
+  }
+}
+function collectExpressionSegments(node, segments) {
+  if (t3.isStringLiteral(node)) {
+    segments.push(segmentFromStringLiteral(node));
+    return;
+  }
+  if (t3.isTemplateLiteral(node) && node.expressions.length === 0) {
+    const quasi = node.quasis[0];
+    if (quasi) {
+      segments.push(segmentFromTemplateElement(quasi));
+    }
+    return;
+  }
+  if (t3.isArrayExpression(node)) {
+    for (const element of node.elements) {
+      if (element) {
+        collectExpressionSegments(element, segments);
+      }
+    }
+    return;
+  }
+  if (t3.isObjectExpression(node)) {
+    for (const property of node.properties) {
+      if (t3.isObjectProperty(property)) {
+        collectObjectPropertySegments(property, segments);
+      }
+    }
+    return;
+  }
+  if (t3.isConditionalExpression(node)) {
+    collectExpressionSegments(node.consequent, segments);
+    collectExpressionSegments(node.alternate, segments);
+    return;
+  }
+  if (t3.isLogicalExpression(node)) {
+    collectExpressionSegments(node.right, segments);
+  }
+}
+function collectObjectPropertySegments(node, segments) {
+  if (t3.isStringLiteral(node.key)) {
+    segments.push(segmentFromStringLiteral(node.key));
+  } else if (t3.isTemplateLiteral(node.key) && node.key.expressions.length === 0) {
+    const quasi = node.key.quasis[0];
+    if (quasi) {
+      segments.push(segmentFromTemplateElement(quasi));
+    }
+  }
+  if (t3.isExpression(node.value)) {
+    collectExpressionSegments(node.value, segments);
+  }
+}
+function isTailwindFunctionCall(node, functionNames) {
+  const name = calleeName(node.callee);
+  return name ? functionNames.has(name) : false;
+}
+function calleeName(node) {
+  if (t3.isIdentifier(node)) {
+    return node.name;
+  }
+  if (t3.isMemberExpression(node) && t3.isIdentifier(node.property) && !node.computed) {
+    return node.property.name;
+  }
+  return void 0;
+}
 function detectConflicts(file, line, classes) {
   const groups = /* @__PURE__ */ new Map();
   for (const className of classes) {
@@ -612,25 +995,83 @@ async function processProjectFiles(options, mode) {
       const result = runCleaner(ImportCleaner, mode, { filePath, source: output, config });
       issues.push(...result.issues);
       output = result.output ?? output;
+      if (hasParseIssue(result.issues)) {
+        processed.push({ filePath, source, output, issues, conflicts });
+        continue;
+      }
     }
     if (config.tailwind) {
       const result = runCleaner(TailwindCleaner, mode, { filePath, source: output, config });
       issues.push(...result.issues);
       conflicts.push(...result.conflicts ?? []);
       output = result.output ?? output;
+      if (hasParseIssue(result.issues)) {
+        processed.push({ filePath, source, output, issues, conflicts });
+        continue;
+      }
+    }
+    if (shouldFormat(config, options)) {
+      const result = await formatWithPrettier(filePath, output);
+      issues.push(...result.issues);
+      output = result.output;
     }
     processed.push({ filePath, source, output, issues, conflicts });
   }
   return processed;
 }
 function runCleaner(cleaner, mode, context) {
-  return mode === "check" ? cleaner.check(context) : cleaner.fix(context);
+  try {
+    return mode === "check" ? cleaner.check(context) : cleaner.fix(context);
+  } catch (error) {
+    return {
+      output: context.source,
+      issues: [
+        {
+          file: context.filePath,
+          line: 1,
+          kind: "parse",
+          message: `Unable to parse file: ${errorMessage(error)}`
+        }
+      ]
+    };
+  }
+}
+function shouldFormat(config, options) {
+  return options.format === true || config.format === "prettier";
+}
+async function formatWithPrettier(filePath, source) {
+  try {
+    const resolvedConfig = await prettier.resolveConfig(filePath);
+    const output = await prettier.format(source, {
+      ...resolvedConfig,
+      filepath: filePath
+    });
+    return { output, issues: [] };
+  } catch (error) {
+    return {
+      output: source,
+      issues: [
+        {
+          file: filePath,
+          line: 1,
+          kind: "format",
+          message: `Unable to format with Prettier: ${errorMessage(error)}`
+        }
+      ]
+    };
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function hasParseIssue(issues) {
+  return issues.some((issue) => issue.kind === "parse");
 }
 
 // src/index.ts
 var program = new Command();
-program.name("cleanwind").description("Clean imports and Tailwind CSS class names.").version("0.1.3");
-program.command("check").description("Check files without writing changes.").option("--cwd <path>", "Working directory").option("--config <path>", "Path to cleanwind config").option("--write", "Write fixes while running check").option("--check", "Force check mode", true).option("--verbose", "Print detailed diagnostics").action(async (options) => {
+program.name("cleanwind").description("Clean imports and Tailwind CSS class names.").version("0.3.0");
+program.command("check").description("Check files without writing changes.").option("--cwd <path>", "Working directory").option("--config <path>", "Path to cleanwind config").option("--write", "Write fixes while running check").option("--check", "Force check mode", true).option("--verbose", "Print detailed diagnostics").option("--format", "Format output with Prettier after cleanup").action(async (options) => {
   const runOptions = toRunOptions(options);
   if (options.write) {
     const result2 = await fix({ ...runOptions, write: true });
@@ -642,7 +1083,7 @@ program.command("check").description("Check files without writing changes.").opt
   printCheckResult(result, options.verbose ?? false);
   process.exitCode = result.ok ? 0 : 1;
 });
-program.command("fix").description("Fix files in place.").option("--cwd <path>", "Working directory").option("--config <path>", "Path to cleanwind config").option("--write", "Write fixes", true).option("--check", "Preview fixes without writing").option("--verbose", "Print detailed diagnostics").option("--staged", "Only fix staged files").action(async (options) => {
+program.command("fix").description("Fix files in place.").option("--cwd <path>", "Working directory").option("--config <path>", "Path to cleanwind config").option("--write", "Write fixes", true).option("--check", "Preview fixes without writing").option("--verbose", "Print detailed diagnostics").option("--staged", "Only fix staged files").option("--format", "Format output with Prettier after cleanup").action(async (options) => {
   const result = await fix({
     ...toRunOptions(options),
     write: options.check ? false : options.write ?? true,
@@ -660,6 +1101,7 @@ function toRunOptions(options) {
   if (options.check !== void 0) runOptions.check = options.check;
   if (options.verbose !== void 0) runOptions.verbose = options.verbose;
   if (options.staged !== void 0) runOptions.staged = options.staged;
+  if (options.format !== void 0) runOptions.format = options.format;
   return runOptions;
 }
 function printCheckResult(result, verbose) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cleanwind",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Clean imports and Tailwind CSS class names from the command line.",
   "type": "module",
   "license": "MIT",
@@ -40,7 +40,8 @@
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",
     "jiti": "^2.4.2",
-    "magic-string": "^0.30.17"
+    "magic-string": "^0.30.17",
+    "prettier": "^3.4.2"
   },
   "devDependencies": {
     "@cleanwind/core": "workspace:*"