tailwind-unwind 0.1.1 → 0.2.0

package/dist/{chunk-N7HD4T2I.js → chunk-FASYIEVZ.js}

@@ -1,3 +1,332 @@
+// src/config/validate.ts
+var CLASS_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+var KNOWN_ROOT_KEYS = /* @__PURE__ */ new Set([
+  "include",
+  "exclude",
+  "names",
+  "prefix",
+  "output",
+  "minOccurrences",
+  "minSize",
+  "maxSize",
+  "top",
+  "dedupeSubsets",
+  "dryRun",
+  "analyze",
+  "generate",
+  "apply"
+]);
+var KNOWN_COMMAND_KEYS = /* @__PURE__ */ new Set([
+  "minOccurrences",
+  "minSize",
+  "maxSize",
+  "top",
+  "prefix",
+  "output",
+  "dedupeSubsets",
+  "dryRun"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertPositiveNumber(value, path6, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+    errors.push(`${path6} must be a positive number`);
+  }
+}
+function assertBoolean(value, path6, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "boolean") {
+    errors.push(`${path6} must be a boolean`);
+  }
+}
+function assertStringArray(value, path6, 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`);
+  }
+}
+function validateCommandSection(value, section, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isRecord(value)) {
+    errors.push(`${section} must be an object`);
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    if (!KNOWN_COMMAND_KEYS.has(key)) {
+      errors.push(`Unknown key "${key}" in ${section}`);
+    }
+  }
+  assertPositiveNumber(value.minOccurrences, `${section}.minOccurrences`, errors);
+  assertPositiveNumber(value.minSize, `${section}.minSize`, errors);
+  assertPositiveNumber(value.maxSize, `${section}.maxSize`, errors);
+  assertPositiveNumber(value.top, `${section}.top`, errors);
+  assertBoolean(value.dedupeSubsets, `${section}.dedupeSubsets`, errors);
+  assertBoolean(value.dryRun, `${section}.dryRun`, errors);
+  if (value.prefix !== void 0 && (typeof value.prefix !== "string" || value.prefix.length === 0)) {
+    errors.push(`${section}.prefix must be a non-empty string`);
+  }
+  if (value.output !== void 0 && (typeof value.output !== "string" || value.output.length === 0)) {
+    errors.push(`${section}.output must be a non-empty string`);
+  }
+}
+function validateNames(value, errors) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isRecord(value)) {
+    errors.push('names must be an object of "utility string": "class-name" pairs');
+    return;
+  }
+  for (const [utilities, name] of Object.entries(value)) {
+    if (typeof utilities !== "string" || utilities.trim().length === 0) {
+      errors.push("names keys must be non-empty utility strings");
+      continue;
+    }
+    if (typeof name !== "string" || !CLASS_NAME_PATTERN.test(name)) {
+      errors.push(
+        `names["${utilities}"] must be a valid class name (letters, numbers, hyphens)`
+      );
+    }
+  }
+}
+function validateConfigFile(raw, configPath) {
+  if (!isRecord(raw)) {
+    throw new Error(`Invalid config in ${configPath}: root value must be an object`);
+  }
+  const source = isRecord(raw.default) ? raw.default : raw;
+  const errors = [];
+  for (const key of Object.keys(source)) {
+    if (!KNOWN_ROOT_KEYS.has(key)) {
+      errors.push(`Unknown config key "${key}"`);
+    }
+  }
+  assertStringArray(source.include, "include", errors);
+  assertStringArray(source.exclude, "exclude", errors);
+  assertPositiveNumber(source.minOccurrences, "minOccurrences", errors);
+  assertPositiveNumber(source.minSize, "minSize", errors);
+  assertPositiveNumber(source.maxSize, "maxSize", errors);
+  assertPositiveNumber(source.top, "top", errors);
+  assertBoolean(source.dedupeSubsets, "dedupeSubsets", errors);
+  assertBoolean(source.dryRun, "dryRun", errors);
+  validateNames(source.names, errors);
+  validateCommandSection(source.analyze, "analyze", errors);
+  validateCommandSection(source.generate, "generate", errors);
+  validateCommandSection(source.apply, "apply", errors);
+  if (source.prefix !== void 0 && (typeof source.prefix !== "string" || source.prefix.length === 0)) {
+    errors.push("prefix must be a non-empty string");
+  }
+  if (source.output !== void 0 && (typeof source.output !== "string" || source.output.length === 0)) {
+    errors.push("output must be a non-empty string");
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Invalid config in ${configPath}:
+${errors.map((error) => `  - ${error}`).join("\n")}`
+    );
+  }
+}
+function normalizeNamesConfig(names) {
+  const map = /* @__PURE__ */ new Map();
+  if (!names) {
+    return map;
+  }
+  for (const [utilities, baseName] of Object.entries(names)) {
+    const tokens = utilities.trim().split(/\s+/).filter((token) => token.length > 0);
+    const key = [...tokens].sort().join(" ");
+    map.set(key, baseName);
+  }
+  return map;
+}
+
+// src/config/loadConfig.ts
+import fs from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+var CONFIG_FILENAMES = [
+  "tailwind-unwind.config.js",
+  "tailwind-unwind.config.mjs",
+  "tailwind-unwind.config.cjs",
+  "tailwind-unwind.config.json",
+  ".tailwind-unwindrc",
+  ".tailwind-unwindrc.json"
+];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pickNumber(source, key) {
+  const value = source[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function pickCommandConfig(source) {
+  const config = {};
+  const minOccurrences = pickNumber(source, "minOccurrences");
+  if (minOccurrences !== void 0) config.minOccurrences = minOccurrences;
+  const minSize = pickNumber(source, "minSize");
+  if (minSize !== void 0) config.minSize = minSize;
+  const maxSize = pickNumber(source, "maxSize");
+  if (maxSize !== void 0) config.maxSize = maxSize;
+  const top = pickNumber(source, "top");
+  if (top !== void 0) config.top = top;
+  if (typeof source.prefix === "string" && source.prefix.length > 0) {
+    config.prefix = source.prefix;
+  }
+  if (typeof source.output === "string" && source.output.length > 0) {
+    config.output = source.output;
+  }
+  if (typeof source.dedupeSubsets === "boolean") {
+    config.dedupeSubsets = source.dedupeSubsets;
+  }
+  if (typeof source.dryRun === "boolean") {
+    config.dryRun = source.dryRun;
+  }
+  return config;
+}
+function pickNames(source) {
+  if (!isRecord2(source.names)) {
+    return void 0;
+  }
+  const names = {};
+  for (const [utilities, name] of Object.entries(source.names)) {
+    if (typeof utilities === "string" && typeof name === "string") {
+      names[utilities] = name;
+    }
+  }
+  return Object.keys(names).length > 0 ? names : void 0;
+}
+function normalizeLoadedConfig(raw) {
+  if (!isRecord2(raw)) {
+    return {};
+  }
+  const source = isRecord2(raw.default) ? raw.default : raw;
+  const config = {
+    ...pickCommandConfig(source)
+  };
+  const names = pickNames(source);
+  if (names) {
+    config.names = names;
+  }
+  if (Array.isArray(source.include)) {
+    config.include = source.include.filter(
+      (item) => typeof item === "string" && item.length > 0
+    );
+  }
+  if (Array.isArray(source.exclude)) {
+    config.exclude = source.exclude.filter(
+      (item) => typeof item === "string" && item.length > 0
+    );
+  }
+  if (isRecord2(source.analyze)) {
+    config.analyze = pickCommandConfig(source.analyze);
+  }
+  if (isRecord2(source.generate)) {
+    config.generate = pickCommandConfig(source.generate);
+  }
+  if (isRecord2(source.apply)) {
+    config.apply = pickCommandConfig(source.apply);
+  }
+  return config;
+}
+function mergeCommandConfig(command, fileConfig) {
+  const { analyze, generate: generate2, apply, ...root } = fileConfig;
+  const commandSection = command === "analyze" ? analyze : command === "generate" ? generate2 : apply;
+  return {
+    ...root,
+    ...commandSection
+  };
+}
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectSearchRoots(cwd, targetPath) {
+  const roots = [path.resolve(cwd)];
+  if (!targetPath) {
+    return roots;
+  }
+  let current = path.resolve(targetPath);
+  try {
+    const stat = await fs.stat(current);
+    if (stat.isFile()) {
+      current = path.dirname(current);
+    }
+  } catch {
+    return roots;
+  }
+  while (true) {
+    const resolved = path.resolve(current);
+    if (!roots.includes(resolved)) {
+      roots.push(resolved);
+    }
+    const parent = path.dirname(resolved);
+    if (parent === resolved) {
+      break;
+    }
+    current = parent;
+  }
+  return roots;
+}
+async function resolveConfigFile(explicitPath, searchRoots) {
+  if (explicitPath) {
+    const resolved = path.resolve(explicitPath);
+    if (!await pathExists(resolved)) {
+      throw new Error(`Config file not found: ${resolved}`);
+    }
+    return resolved;
+  }
+  for (const root of searchRoots) {
+    for (const filename of CONFIG_FILENAMES) {
+      const candidate = path.join(root, filename);
+      if (await pathExists(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+async function importConfigModule(configPath) {
+  const moduleUrl = pathToFileURL(configPath).href;
+  const imported = await import(moduleUrl);
+  return imported;
+}
+async function readJsonConfig(configPath) {
+  const raw = await fs.readFile(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function loadCommandOptions(command, cliOptions, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const searchRoots = await collectSearchRoots(cwd, options.targetPath);
+  const configPath = await resolveConfigFile(cliOptions.configPath, searchRoots);
+  if (!configPath) {
+    return cliOptions;
+  }
+  const isJson = configPath.endsWith(".json") || configPath.endsWith(".tailwind-unwindrc");
+  const loaded = isJson ? await readJsonConfig(configPath) : await importConfigModule(configPath);
+  validateConfigFile(loaded, configPath);
+  const fileConfig = mergeCommandConfig(command, normalizeLoadedConfig(loaded));
+  const { configPath: _ignored, ...cliOverrides } = cliOptions;
+  return {
+    ...fileConfig,
+    ...Object.fromEntries(
+      Object.entries(cliOverrides).filter(([, value]) => value !== void 0)
+    ),
+    configPath
+  };
+}
+
 // src/analyzer/suggestions.ts
 var BREAKPOINT_PREFIX = /^(sm|md|lg|xl|2xl):/;
 function baseClass(cls) {
@@ -793,7 +1122,7 @@ function parseSourceToAst(source) {
 
 // src/parser/jsxParser.ts
 import babelTraverse from "@babel/traverse";
-import fs from "fs/promises";
+import fs2 from "fs/promises";
 function resolveTraverse(module) {
   if (typeof module === "function") {
     return module;
@@ -805,8 +1134,8 @@ function resolveTraverse(module) {
   throw new Error("Failed to load @babel/traverse");
 }
 var traverse = resolveTraverse(babelTraverse);
-function isJSXElementWithClassAttribute(path5) {
-  const opening = path5.node.openingElement;
+function isJSXElementWithClassAttribute(path6) {
+  const opening = path6.node.openingElement;
   return opening.attributes.some(
     (attr) => attr.type === "JSXAttribute" && isClassAttribute(attr)
   );
@@ -815,11 +1144,11 @@ function collectExtractionsFromAst(ast, filePath) {
   const extractions = [];
   const warnings = [];
   traverse(ast, {
-    JSXElement(path5) {
-      if (!isJSXElementWithClassAttribute(path5)) {
+    JSXElement(path6) {
+      if (!isJSXElementWithClassAttribute(path6)) {
         return;
       }
-      const opening = path5.node.openingElement;
+      const opening = path6.node.openingElement;
       for (const attr of opening.attributes) {
         if (attr.type !== "JSXAttribute") continue;
         const extraction = extractFromJSXAttribute(attr);
@@ -854,7 +1183,7 @@ function parseSource(source, filePath = "unknown") {
   return { filePath, extractions, warnings };
 }
 async function parseFile(filePath) {
-  const source = await fs.readFile(filePath, "utf-8");
+  const source = await fs2.readFile(filePath, "utf-8");
   return parseSource(source, filePath);
 }
 
@@ -872,40 +1201,67 @@ var IGNORE_PATTERNS = IGNORED_DIRECTORIES.map(
 
 // src/scanner/fileWalker.ts
 import fg from "fast-glob";
-import path from "path";
+import path2 from "path";
 var SOURCE_EXTENSIONS = ["tsx", "jsx", "ts", "js"];
-async function walkSourceFiles(targetPath) {
-  const absolutePath = path.resolve(targetPath);
-  const patterns = SOURCE_EXTENSIONS.map(
-    (ext) => path.join(absolutePath, `**/*.${ext}`).replace(/\\/g, "/")
+function toAbsolutePattern(basePath, pattern) {
+  const normalized = pattern.replace(/\\/g, "/");
+  if (path2.isAbsolute(normalized)) {
+    return normalized;
+  }
+  return path2.join(basePath, normalized).replace(/\\/g, "/");
+}
+function buildIncludePatterns(basePath, include) {
+  if (include && include.length > 0) {
+    return include.map((pattern) => toAbsolutePattern(basePath, pattern));
+  }
+  return SOURCE_EXTENSIONS.map(
+    (ext) => path2.join(basePath, `**/*.${ext}`).replace(/\\/g, "/")
   );
+}
+function buildIgnorePatterns(exclude) {
+  const userExcludes = (exclude ?? []).map((pattern) => {
+    const normalized = pattern.replace(/\\/g, "/");
+    if (normalized.startsWith("**")) {
+      return normalized;
+    }
+    return `**/${normalized}`;
+  });
+  return [...IGNORE_PATTERNS, ...userExcludes];
+}
+async function walkSourceFiles(targetPath, options = {}) {
+  const absolutePath = path2.resolve(targetPath);
+  const patterns = buildIncludePatterns(absolutePath, options.include);
+  const ignore = buildIgnorePatterns(options.exclude);
   const files = await fg(patterns, {
     absolute: true,
     onlyFiles: true,
     unique: true,
-    ignore: IGNORE_PATTERNS,
+    ignore,
     dot: false
   });
   return files.sort();
 }
 
 // src/core/scanProject.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-async function pathExists(targetPath) {
+import fs3 from "fs/promises";
+import path3 from "path";
+async function pathExists2(targetPath) {
   try {
-    await fs2.access(targetPath);
+    await fs3.access(targetPath);
     return true;
   } catch {
     return false;
   }
 }
 async function scanProject(options) {
-  const resolvedPath = path2.resolve(options.targetPath);
-  if (!await pathExists(resolvedPath)) {
+  const resolvedPath = path3.resolve(options.targetPath);
+  if (!await pathExists2(resolvedPath)) {
     throw new Error(`Path does not exist: ${resolvedPath}`);
   }
-  const files = await walkSourceFiles(resolvedPath);
+  const files = await walkSourceFiles(resolvedPath, {
+    include: options.include,
+    exclude: options.exclude
+  });
   if (files.length === 0) {
     throw new Error(
       `No source files (.tsx, .jsx, .ts, .js) found in: ${resolvedPath}`
@@ -931,13 +1287,26 @@ async function scanProject(options) {
       (occurrence) => normalizeClasses([...new Set(occurrence.classes)])
     )
   );
-  const topCombinations = findFrequentPatterns(occurrences, {
+  const frequentCombinations = findFrequentPatterns(occurrences, {
     minOccurrences: options.minOccurrences,
     minSize: options.minSize,
     maxSize: options.maxSize,
     topLimit: options.topLimit,
     dedupeSubsets: options.dedupeSubsets
   });
+  const extractableSets = findRepeatedClassSets(occurrences, {
+    minOccurrences: options.extractableMinOccurrences ?? 3,
+    minSize: options.minSize,
+    maxSize: options.maxSize,
+    topLimit: Number.POSITIVE_INFINITY
+  });
+  const extractableKeys = new Set(
+    extractableSets.map((combo) => combo.normalized)
+  );
+  const topCombinations = frequentCombinations.map((combo) => ({
+    ...combo,
+    extractable: extractableKeys.has(combo.normalized)
+  }));
   const potentialReductionPercent = calculatePotentialReduction(
     occurrences,
     topCombinations
@@ -1015,6 +1384,15 @@ function printConsoleReport(report, options = {}) {
       console.log(
         chalk.gray(`   Suggestion: `) + chalk.green(combo.suggestion)
       );
+      if (combo.extractable) {
+        console.log(
+          chalk.gray(`   Extractable: `) + chalk.green("yes \u2014 use generate/apply")
+        );
+      } else {
+        console.log(
+          chalk.gray(`   Extractable: `) + chalk.yellow("subset only \u2014 analyze hint")
+        );
+      }
       console.log(
         chalk.gray(`   Found in: `) + chalk.dim(formatLocations(combo.locations))
       );
@@ -1026,6 +1404,16 @@ function printConsoleReport(report, options = {}) {
       `\u{1F4A1} Potential code reduction: ${stats.potentialReductionPercent}%`
     )
   );
+  const extractableCount = stats.topCombinations.filter(
+    (combo) => combo.extractable
+  ).length;
+  if (extractableCount > 0) {
+    console.log(
+      chalk.magenta(
+        `\u{1F4A1} ${extractableCount} pattern(s) ready for generate/apply`
+      )
+    );
+  }
   console.log(
     chalk.magenta(
       "\u{1F4A1} Generate CSS: npx tailwind-unwind generate <path> --output styles.css"
@@ -1055,7 +1443,10 @@ async function analyzeCommand(targetPath, options = {}) {
       minSize: options.minSize,
       maxSize: options.maxSize,
       topLimit: options.top,
-      dedupeSubsets: options.dedupeSubsets
+      dedupeSubsets: options.dedupeSubsets,
+      include: options.include,
+      exclude: options.exclude,
+      extractableMinOccurrences: 3
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1102,6 +1493,18 @@ function resolveGenerator(module) {
 }
 var traverse2 = resolveTraverse2(babelTraverse2);
 var generate = resolveGenerator(babelGenerate);
+function isClassMergeCallee2(expression) {
+  if (expression.type === "Identifier") {
+    return CLASS_MERGE_CALLEES.has(expression.name);
+  }
+  if (expression.type === "MemberExpression" && expression.property.type === "Identifier") {
+    return CLASS_MERGE_CALLEES.has(expression.property.name);
+  }
+  return false;
+}
+function isClassMergeCall(expression) {
+  return expression.type === "CallExpression" && expression.callee.type !== "V8IntrinsicIdentifier" && isClassMergeCallee2(expression.callee);
+}
 function lookupReplacement(extraction, replacementMap) {
   if (extraction.isDynamic || extraction.classes.length === 0) {
     return null;
@@ -1112,6 +1515,88 @@ function lookupReplacement(extraction, replacementMap) {
 function setStringClassAttribute(attr, className) {
   attr.value = t.stringLiteral(className);
 }
+function tryReplaceMergeCall(call, replacementMap) {
+  const staticClasses = [];
+  const dynamicArgs = [];
+  for (const arg of call.arguments) {
+    if (arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder") {
+      dynamicArgs.push(arg);
+      continue;
+    }
+    const extracted = extractClassesFromExpression(arg);
+    if (extracted.isDynamic) {
+      dynamicArgs.push(arg);
+      continue;
+    }
+    staticClasses.push(...extracted.classes);
+  }
+  const combinedKey = normalizeClasses([...new Set(staticClasses)]);
+  const combinedReplacement = replacementMap.get(combinedKey);
+  if (combinedReplacement && staticClasses.length > 0) {
+    if (dynamicArgs.length === 0) {
+      return {
+        expression: t.stringLiteral(combinedReplacement),
+        from: combinedKey,
+        to: combinedReplacement,
+        partial: false
+      };
+    }
+    return {
+      expression: t.callExpression(call.callee, [
+        t.stringLiteral(combinedReplacement),
+        ...dynamicArgs
+      ]),
+      from: combinedKey,
+      to: combinedReplacement,
+      partial: true
+    };
+  }
+  let replaced = false;
+  let replacedTo = "";
+  let replacedFrom = "";
+  const newArgs = [...call.arguments];
+  for (let index = 0; index < call.arguments.length; index += 1) {
+    const arg = call.arguments[index];
+    if (arg === void 0 || arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder") {
+      continue;
+    }
+    const extracted = extractClassesFromExpression(arg);
+    if (extracted.isDynamic || extracted.classes.length === 0) {
+      continue;
+    }
+    const argKey = normalizeClasses(extracted.classes);
+    const replacement = replacementMap.get(argKey);
+    if (!replacement) {
+      continue;
+    }
+    newArgs[index] = t.stringLiteral(replacement);
+    if (!replaced) {
+      replacedFrom = argKey;
+      replacedTo = replacement;
+    }
+    replaced = true;
+  }
+  if (!replaced) {
+    return null;
+  }
+  return {
+    expression: t.callExpression(call.callee, newArgs),
+    from: replacedFrom,
+    to: replacedTo,
+    partial: true
+  };
+}
+function tryReplaceClassAttribute(attr, replacementMap) {
+  const value = attr.value;
+  if (value?.type !== "JSXExpressionContainer") {
+    return null;
+  }
+  const expression = value.expression;
+  if (expression.type === "JSXEmptyExpression" || !isClassMergeCall(expression)) {
+    return null;
+  }
+  return tryReplaceMergeCall(expression, replacementMap);
+}
 function replaceClassNamesInSource(source, replacementMap, filePath) {
   const replacements = [];
   const skipped = [];
@@ -1126,14 +1611,30 @@ function replaceClassNamesInSource(source, replacementMap, filePath) {
     throw new Error(`Failed to parse ${filePath}: ${message}`);
   }
   traverse2(ast, {
-    JSXElement(path5) {
-      const opening = path5.node.openingElement;
+    JSXElement(path6) {
+      const opening = path6.node.openingElement;
       for (const attr of opening.attributes) {
         if (attr.type !== "JSXAttribute" || !isClassAttribute(attr)) {
           continue;
         }
         const extraction = extractFromJSXAttribute(attr);
         if (!extraction) continue;
+        const mergeReplacement = tryReplaceClassAttribute(attr, replacementMap);
+        if (mergeReplacement) {
+          if (mergeReplacement.expression.type === "StringLiteral") {
+            setStringClassAttribute(attr, mergeReplacement.expression.value);
+          } else {
+            attr.value = t.jsxExpressionContainer(mergeReplacement.expression);
+          }
+          replacements.push({
+            filePath,
+            line: extraction.line,
+            from: mergeReplacement.from,
+            to: mergeReplacement.to,
+            partial: mergeReplacement.partial
+          });
+          continue;
+        }
         const replacement = lookupReplacement(extraction, replacementMap);
         if (!replacement) {
           if (extraction.classes.length > 0) {
@@ -1192,10 +1693,15 @@ function withClassPrefix(baseName, prefix) {
 }
 
 // src/generator/cssGenerator.ts
+function resolveBaseClassName(classes, customNames) {
+  const key = normalizeClasses(classes);
+  return customNames.get(key) ?? suggestClassName(classes);
+}
 function assignComponentClassNames(combinations, options = {}) {
   const used = /* @__PURE__ */ new Set();
+  const customNames = normalizeNamesConfig(options.names);
   return combinations.map((combo) => {
-    const base = suggestClassName(combo.classes);
+    const base = resolveBaseClassName(combo.classes, customNames);
     let className = withClassPrefix(base, options.prefix);
     let suffix = 2;
     while (used.has(className)) {
@@ -1212,7 +1718,8 @@ function assignComponentClassNames(combinations, options = {}) {
 }
 function generateComponentCss(options) {
   const components = assignComponentClassNames(options.combinations, {
-    prefix: options.prefix
+    prefix: options.prefix,
+    names: options.names
   });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const classPrefix = normalizeClassPrefix(options.prefix);
@@ -1258,7 +1765,8 @@ function buildComponents(occurrences, options) {
   const { css, components } = generateComponentCss({
     sourcePath: options.sourcePath,
     combinations,
-    prefix: options.prefix
+    prefix: options.prefix,
+    names: options.names
   });
   const replacementMap = /* @__PURE__ */ new Map();
   for (const component of components) {
@@ -1269,13 +1777,17 @@ function buildComponents(occurrences, options) {
 }
 
 // src/commands/apply.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 import chalk3 from "chalk";
 async function applyCommand(targetPath, options) {
   let scanResult;
   try {
-    scanResult = await scanProject({ targetPath });
+    scanResult = await scanProject({
+      targetPath,
+      include: options.include,
+      exclude: options.exclude
+    });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(chalk3.red(`Error: ${message}`));
@@ -1292,7 +1804,8 @@ async function applyCommand(targetPath, options) {
       minSize: options.minSize,
       maxSize: options.maxSize,
       topLimit: options.top,
-      prefix: options.prefix
+      prefix: options.prefix,
+      names: options.names
     }
   );
   if (components.length === 0) {
@@ -1303,12 +1816,13 @@ async function applyCommand(targetPath, options) {
     );
     process.exit(1);
   }
-  const outputPath = path3.resolve(options.output);
+  const outputPath = path4.resolve(options.output);
   let filesModified = 0;
   let replacementsTotal = 0;
   const allReplacements = [];
+  const allSkipped = [];
   for (const file of scanResult.files) {
-    const original = await fs3.readFile(file, "utf-8");
+    const original = await fs4.readFile(file, "utf-8");
     const result = replaceClassNamesInSource(
       original,
       replacementMap,
@@ -1316,16 +1830,17 @@ async function applyCommand(targetPath, options) {
     );
     replacementsTotal += result.replacements.length;
     allReplacements.push(...result.replacements);
+    allSkipped.push(...result.skipped);
     if (result.changed) {
       filesModified += 1;
       if (!options.dryRun) {
-        await fs3.writeFile(file, result.source, "utf-8");
+        await fs4.writeFile(file, result.source, "utf-8");
       }
     }
   }
   if (!options.dryRun) {
-    await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
-    await fs3.writeFile(outputPath, css, "utf-8");
+    await fs4.mkdir(path4.dirname(outputPath), { recursive: true });
+    await fs4.writeFile(outputPath, css, "utf-8");
   }
   console.log("");
   if (options.dryRun) {
@@ -1348,8 +1863,22 @@ async function applyCommand(targetPath, options) {
     console.log(chalk3.bold("Replacements:"));
     for (const item of allReplacements) {
       const line = item.line ? `:${item.line}` : "";
+      const partialTag = item.partial ? chalk3.dim(" (partial)") : "";
       console.log(
-        chalk3.gray(`  ${item.filePath}${line}`) + chalk3.white(` "${item.from}" `) + chalk3.cyan("\u2192") + chalk3.green(` "${item.to}"`)
+        chalk3.gray(`  ${item.filePath}${line}`) + chalk3.white(` "${item.from}" `) + chalk3.cyan("\u2192") + chalk3.green(` "${item.to}"`) + partialTag
+      );
+    }
+  }
+  if (allSkipped.length > 0) {
+    console.log("");
+    console.log(
+      chalk3.bold.yellow(`Skipped (${allSkipped.length}):`)
+    );
+    for (const item of allSkipped) {
+      const line = item.line ? `:${item.line}` : "";
+      const classes = item.classes.join(" ");
+      console.log(
+        chalk3.gray(`  ${item.filePath}${line}`) + chalk3.yellow(` [${item.reason}]`) + chalk3.dim(` "${classes}"`)
       );
     }
   }
@@ -1357,7 +1886,7 @@ async function applyCommand(targetPath, options) {
   if (!options.dryRun) {
     console.log(
       chalk3.cyan(
-        `Import ${path3.basename(outputPath)} in your global CSS if you haven't already.`
+        `Import ${path4.basename(outputPath)} in your global CSS if you haven't already.`
       )
     );
     console.log("");
@@ -1371,13 +1900,17 @@ async function applyCommand(targetPath, options) {
 }
 
 // src/commands/generate.ts
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 import chalk4 from "chalk";
 async function generateCommand(targetPath, options) {
   let scanResult;
   try {
-    scanResult = await scanProject({ targetPath });
+    scanResult = await scanProject({
+      targetPath,
+      include: options.include,
+      exclude: options.exclude
+    });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(chalk4.red(`Error: ${message}`));
@@ -1392,11 +1925,12 @@ async function generateCommand(targetPath, options) {
     minSize: options.minSize,
     maxSize: options.maxSize,
     topLimit: options.top,
-    prefix: options.prefix
+    prefix: options.prefix,
+    names: options.names
   });
-  const outputPath = path4.resolve(options.output);
-  await fs4.mkdir(path4.dirname(outputPath), { recursive: true });
-  await fs4.writeFile(outputPath, css, "utf-8");
+  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));
@@ -1433,6 +1967,9 @@ async function generateCommand(targetPath, options) {
 }
 
 export {
+  validateConfigFile,
+  normalizeNamesConfig,
+  loadCommandOptions,
   suggestClassName,
   isStrictSubset,
   dedupeSubsetCombinations,
@@ -1466,4 +2003,4 @@ export {
   applyCommand,
   generateCommand
 };
-//# sourceMappingURL=chunk-N7HD4T2I.js.map
+//# sourceMappingURL=chunk-FASYIEVZ.js.map