cleanwind 0.1.0 → 0.1.2

package/README.md

@@ -35,7 +35,7 @@ cleanwind fix --check
 cleanwind fix --cwd ./apps/web --verbose
 ```
 
-## Packages
+## Package
 
-The CLI uses `@cleanwind/core` internally. Use `@cleanwind/core` directly when
-you want to build custom integrations.
+The published CLI bundles the cleanwind core engine, so installing `cleanwind`
+does not require a separate core package.

package/dist/index.js

@@ -2,9 +2,634 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { check, fix } from "@cleanwind/core";
+
+// ../core/dist/index.js
+import { existsSync } from "fs";
+import path from "path";
+import { createJiti } from "jiti";
+import * as t2 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 { promises as fs } from "fs";
+import path3 from "path";
+import { execFileSync } from "child_process";
+import path2 from "path";
+import fg from "fast-glob";
+var defaultConfig = {
+  imports: true,
+  tailwind: true,
+  removeDuplicateImports: true,
+  removeDuplicateClasses: true,
+  sortImports: true,
+  sortTailwindClasses: true,
+  detectConflicts: true,
+  include: ["src/**/*.{js,jsx,ts,tsx}"],
+  exclude: ["node_modules", ".next", "dist"]
+};
+var configFiles = [
+  "cleanwind.config.ts",
+  "cleanwind.config.mts",
+  "cleanwind.config.js",
+  "cleanwind.config.mjs"
+];
+async function loadConfig(cwd, configPath) {
+  const resolvedPath = configPath ? path.resolve(cwd, configPath) : findConfig(cwd);
+  if (!resolvedPath) {
+    return defaultConfig;
+  }
+  const jiti = createJiti(import.meta.url, { moduleCache: false });
+  const loaded = await jiti.import(resolvedPath, { default: true });
+  return {
+    ...defaultConfig,
+    ...loaded,
+    include: loaded.include ?? defaultConfig.include,
+    exclude: loaded.exclude ?? defaultConfig.exclude
+  };
+}
+function findConfig(cwd) {
+  for (const file of configFiles) {
+    const candidate = path.join(cwd, file);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+var plugins = [
+  "jsx",
+  "typescript",
+  "decorators-legacy",
+  "classProperties",
+  "classPrivateProperties",
+  "classPrivateMethods",
+  "dynamicImport",
+  "importAttributes"
+];
+function parseSource(source) {
+  return parse(source, {
+    sourceType: "module",
+    plugins,
+    errorRecovery: true,
+    tokens: true
+  });
+}
+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) {
+    const fixed = this.fix(context);
+    const issues = [];
+    if (fixed.output !== context.source) {
+      issues.push({
+        file: context.filePath,
+        line: 1,
+        kind: "imports",
+        message: "Imports are not tidy."
+      });
+    }
+    return { output: fixed.output, issues };
+  }
+  /** 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);
+    if (imports.length === 0) {
+      return { output: context.source, issues: [] };
+    }
+    const usedIdentifiers = collectUsedIdentifiers(ast);
+    const records = buildImportRecords(imports, usedIdentifiers, context.config.sortImports);
+    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();
+  for (const statement of ast.program.body) {
+    if (t2.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);
+      }
+    });
+  }
+  return identifiers;
+}
+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)
+    return false;
+  if ((t2.isClassDeclaration(parent) || t2.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;
+  return true;
+}
+function isJSXIdentifierReference(parent, node) {
+  if (!parent) {
+    return false;
+  }
+  if (t2.isJSXAttribute(parent)) {
+    return false;
+  }
+  return t2.isJSXOpeningElement(parent) && parent.name === node || t2.isJSXClosingElement(parent) && parent.name === node || t2.isJSXMemberExpression(parent) && parent.object === node;
+}
+function buildImportRecords(declarations, usedIdentifiers, sort) {
+  const records = /* @__PURE__ */ new Map();
+  const sideEffects = [];
+  for (const declaration of declarations) {
+    const source = declaration.source.value;
+    const sideEffect = declaration.specifiers.length === 0;
+    if (sideEffect) {
+      sideEffects.push({
+        source,
+        named: [],
+        sideEffect: true,
+        group: classifyImport(source)
+      });
+      continue;
+    }
+    const key = source;
+    const record = records.get(key) ?? {
+      source,
+      named: [],
+      sideEffect: false,
+      group: classifyImport(source)
+    };
+    for (const specifier of declaration.specifiers) {
+      const local = specifier.local.name;
+      if (!usedIdentifiers.has(local)) {
+        continue;
+      }
+      if (t2.isImportDefaultSpecifier(specifier)) {
+        record.defaultName ??= local;
+      } else if (t2.isImportNamespaceSpecifier(specifier)) {
+        record.namespaceName ??= local;
+      } else if (t2.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 merged = [...records.values(), ...sideEffects];
+  return sort ? sortRecords(merged) : merged;
+}
+function importPartFromSpecifier(specifier, declarationKind) {
+  const imported = t2.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+  return {
+    imported,
+    local: specifier.local.name,
+    kind: specifier.importKind === "type" ? "type" : declarationKind
+  };
+}
+function dedupeRecord(record) {
+  const named = /* @__PURE__ */ new Map();
+  for (const part of record.named) {
+    named.set(`${part.kind}:${part.imported}:${part.local}`, part);
+  }
+  return {
+    ...record,
+    named: [...named.values()].sort((left, right) => left.imported.localeCompare(right.imported))
+  };
+}
+function sortRecords(records) {
+  const groupRank = {
+    package: 0,
+    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;
+    }
+    return left.source.localeCompare(right.source);
+  });
+}
+function classifyImport(source) {
+  if (source.startsWith("@/")) {
+    return "alias";
+  }
+  if (source.startsWith(".")) {
+    return "relative";
+  }
+  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")}
+
+` : "";
+}
+function renderImportRecord(record) {
+  if (record.sideEffect) {
+    return `import ${JSON.stringify(record.source)};`;
+  }
+  const parts = [];
+  if (record.defaultName) {
+    parts.push(record.defaultName);
+  }
+  if (record.namespaceName) {
+    parts.push(`* as ${record.namespaceName}`);
+  }
+  if (record.named.length > 0) {
+    parts.push(`{ ${record.named.map(renderNamedPart).join(", ")} }`);
+  }
+  return `import ${parts.join(", ")} from ${JSON.stringify(record.source)};`;
+}
+function renderNamedPart(part) {
+  const prefix = part.kind === "type" ? "type " : "";
+  const names = part.imported === part.local ? part.imported : `${part.imported} as ${part.local}`;
+  return `${prefix}${names}`;
+}
+function spanForImport(source, declaration) {
+  const start = declaration.start ?? 0;
+  let end = declaration.end ?? start;
+  while (end < source.length && (source[end] === "\r" || source[end] === "\n")) {
+    end += 1;
+  }
+  return { start, end };
+}
+function replaceImports(source, spans, importBlock) {
+  const magic = new MagicString(source);
+  const sortedSpans = [...spans].sort((left, right) => left.start - right.start);
+  const firstStart = sortedSpans[0]?.start ?? 0;
+  for (const span of sortedSpans) {
+    magic.remove(span.start, span.end);
+  }
+  magic.appendLeft(firstStart, importBlock);
+  return magic.toString().replace(/^\n+/u, "");
+}
+var displayClasses = /* @__PURE__ */ new Set([
+  "block",
+  "inline-block",
+  "inline",
+  "flex",
+  "inline-flex",
+  "grid",
+  "inline-grid",
+  "contents",
+  "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;
+  return classes.join(" ");
+}
+function splitClasses(value) {
+  return value.split(/\s+/u).map((item) => item.trim()).filter(Boolean);
+}
+function compareTailwindClasses(left, right) {
+  const leftClass = classifyClass(left);
+  const rightClass = classifyClass(right);
+  const variantDelta = leftClass.variant.localeCompare(rightClass.variant);
+  if (variantDelta !== 0) {
+    return variantDelta;
+  }
+  const rankDelta = leftClass.rank - rightClass.rank;
+  if (rankDelta !== 0) {
+    return rankDelta;
+  }
+  return leftClass.utility.localeCompare(rightClass.utility);
+}
+function conflictKey(className) {
+  const classified = classifyClass(className);
+  const utility = stripImportant(classified.utility);
+  const variantPrefix = classified.variant ? `${classified.variant}:` : "";
+  if (displayClasses.has(utility)) {
+    return `${variantPrefix}display`;
+  }
+  if (positionClasses.has(utility)) {
+    return `${variantPrefix}position`;
+  }
+  const spacing = spacingConflictKey(utility);
+  if (spacing) {
+    return `${variantPrefix}${spacing}`;
+  }
+  if (/^text-(xs|sm|base|lg|xl|[2-9]xl)$/u.test(utility)) {
+    return `${variantPrefix}font-size`;
+  }
+  if (utility.startsWith("bg-")) {
+    return `${variantPrefix}background-color`;
+  }
+  return void 0;
+}
+function spacingConflictKey(utility) {
+  const match = /^(?<property>[mp])(?<axis>x|y|t|r|b|l)?-/u.exec(utility);
+  if (!match?.groups) {
+    return void 0;
+  }
+  const property = match.groups.property;
+  const axis = match.groups.axis ?? "all";
+  return `${property}-${axis}`;
+}
+function classifyClass(className) {
+  const parts = splitVariant(className);
+  const utility = parts.utility;
+  return {
+    variant: parts.variant,
+    utility,
+    rank: rankUtility(stripImportant(utility))
+  };
+}
+function splitVariant(className) {
+  let bracketDepth = 0;
+  for (let index = className.length - 1; index >= 0; index -= 1) {
+    const char = className[index];
+    if (char === "]") {
+      bracketDepth += 1;
+    } else if (char === "[") {
+      bracketDepth -= 1;
+    } else if (char === ":" && bracketDepth === 0) {
+      return {
+        variant: className.slice(0, index),
+        utility: className.slice(index + 1)
+      };
+    }
+  }
+  return { variant: "", utility: className };
+}
+function stripImportant(utility) {
+  return utility.startsWith("!") ? utility.slice(1) : utility;
+}
+function rankUtility(utility) {
+  if (utility.startsWith("container")) return 0;
+  if (positionClasses.has(utility) || utility.startsWith("inset-")) return 10;
+  if (displayClasses.has(utility)) return 20;
+  if (utility.startsWith("float-") || utility.startsWith("clear-")) return 30;
+  if (utility.startsWith("flex-") || utility.startsWith("basis-") || utility.startsWith("grow") || utility.startsWith("shrink"))
+    return 40;
+  if (utility.startsWith("grid-") || utility.startsWith("col-") || utility.startsWith("row-") || utility.startsWith("gap-"))
+    return 50;
+  if (/^-?[mp][trblxy]?-/u.test(utility)) return 60;
+  if (/^(w|h|min-w|min-h|max-w|max-h)-/u.test(utility)) return 70;
+  if (utility.startsWith("font-") || utility.startsWith("text-") || utility.startsWith("leading-") || utility.startsWith("tracking-"))
+    return 80;
+  if (utility.startsWith("bg-")) return 90;
+  if (utility.startsWith("border") || utility.startsWith("rounded")) return 100;
+  if (utility.startsWith("shadow") || utility.startsWith("opacity-")) return 110;
+  if (utility.startsWith("transition") || utility.startsWith("duration-") || utility.startsWith("ease-"))
+    return 120;
+  if (utility.startsWith("animate-")) return 130;
+  return 1e3;
+}
+var TailwindCleaner = class {
+  /** Checks whether Tailwind class strings would change and reports conflicts. */
+  static check(context) {
+    const fixed = this.fix(context);
+    const issues = [];
+    if (fixed.output !== context.source) {
+      issues.push({
+        file: context.filePath,
+        line: 1,
+        kind: "tailwind",
+        message: "Tailwind classes are not tidy."
+      });
+    }
+    issues.push(...fixed.issues);
+    return fixed.conflicts ? { output: fixed.output, issues, conflicts: fixed.conflicts } : { output: fixed.output, issues };
+  }
+  /** Returns source text with duplicated and unordered Tailwind classes normalized. */
+  static fix(context) {
+    const ast = parseSource(context.source);
+    const segments = collectClassSegments(ast);
+    const magic = new MagicString2(context.source);
+    const conflicts = [];
+    for (const segment of segments) {
+      const nextValue = normalizeClassList(segment.value, context.config.sortTailwindClasses);
+      if (nextValue !== segment.value) {
+        magic.overwrite(segment.start, segment.end, nextValue);
+      }
+      if (context.config.detectConflicts) {
+        conflicts.push(
+          ...detectConflicts(context.filePath, segment.line, splitClasses(segment.value))
+        );
+      }
+    }
+    return {
+      output: magic.toString(),
+      issues: conflicts.map((conflict) => ({
+        file: conflict.file,
+        line: conflict.line,
+        kind: "conflict",
+        message: conflict.suggestion
+      })),
+      conflicts
+    };
+  }
+};
+function collectClassSegments(ast) {
+  const segments = [];
+  walkNode(ast, (node) => {
+    if (t3.isJSXAttribute(node)) {
+      if (!isClassAttribute(node)) {
+        return;
+      }
+      const value = node.value;
+      if (t3.isStringLiteral(value)) {
+        segments.push(segmentFromStringLiteral(value));
+      } else if (t3.isJSXExpressionContainer(value) && t3.isStringLiteral(value.expression)) {
+        segments.push(segmentFromStringLiteral(value.expression));
+      } else if (t3.isJSXExpressionContainer(value) && t3.isTemplateLiteral(value.expression) && value.expression.expressions.length === 0) {
+        const quasi = value.expression.quasis[0];
+        if (quasi) {
+          segments.push(segmentFromTemplateElement(quasi));
+        }
+      }
+    }
+  });
+  return segments;
+}
+function isClassAttribute(node) {
+  return t3.isJSXIdentifier(node.name) && (node.name.name === "className" || node.name.name === "class");
+}
+function segmentFromStringLiteral(node) {
+  const start = (node.start ?? 0) + 1;
+  const end = (node.end ?? start) - 1;
+  return {
+    start,
+    end,
+    value: node.value,
+    line: node.loc?.start.line ?? 1
+  };
+}
+function segmentFromTemplateElement(node) {
+  const start = (node.start ?? 0) + 1;
+  const end = (node.end ?? start) - 1;
+  return {
+    start,
+    end,
+    value: node.value.raw,
+    line: node.loc?.start.line ?? 1
+  };
+}
+function detectConflicts(file, line, classes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const className of classes) {
+    const key = conflictKey(className);
+    if (!key) {
+      continue;
+    }
+    const group = groups.get(key) ?? [];
+    group.push(className);
+    groups.set(key, group);
+  }
+  return [...groups.values()].flatMap((group) => {
+    const unique = [...new Set(group)];
+    if (unique.length <= 1) {
+      return [];
+    }
+    return {
+      file,
+      line,
+      conflictingClasses: unique,
+      suggestion: `Conflicting Tailwind utilities found: ${unique.join(", ")}. Choose the intended utility.`
+    };
+  });
+}
+var sourceExtensions = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
+async function findProjectFiles(cwd, config, staged) {
+  if (staged) {
+    return findStagedFiles(cwd, config);
+  }
+  const files = await fg(config.include, {
+    cwd,
+    absolute: true,
+    dot: true,
+    ignore: config.exclude
+  });
+  return files.map((file) => path2.normalize(file));
+}
+function findStagedFiles(cwd, config) {
+  const output = execFileSync("git", ["diff", "--name-only", "--cached", "--diff-filter=ACMR"], {
+    cwd,
+    encoding: "utf8"
+  });
+  return output.split(/\r?\n/u).map((file) => file.trim()).filter(Boolean).filter((file) => sourceExtensions.has(path2.extname(file))).filter(
+    (file) => !config.exclude.some((excluded) => file === excluded || file.startsWith(`${excluded}/`))
+  ).map((file) => path2.resolve(cwd, file));
+}
+async function check(options = {}) {
+  const files = await processProjectFiles(options, "check");
+  const issues = [];
+  const conflicts = [];
+  const changedFiles = [];
+  for (const file of files) {
+    issues.push(...file.issues);
+    conflicts.push(...file.conflicts);
+    if (file.output !== file.source) {
+      changedFiles.push(file.filePath);
+    }
+  }
+  return {
+    ok: issues.length === 0 && conflicts.length === 0 && changedFiles.length === 0,
+    issues,
+    conflicts,
+    changedFiles
+  };
+}
+async function fix(options = {}) {
+  const files = await processProjectFiles(options, "fix");
+  const write = options.write ?? true;
+  const changes = [];
+  const writtenFiles = [];
+  const issues = files.flatMap((file) => file.issues);
+  const conflicts = files.flatMap((file) => file.conflicts);
+  for (const file of files) {
+    if (file.output === file.source) {
+      continue;
+    }
+    changes.push({ file: file.filePath, before: file.source, after: file.output });
+    if (write) {
+      await fs.writeFile(file.filePath, file.output, "utf8");
+      writtenFiles.push(file.filePath);
+    }
+  }
+  return {
+    ok: issues.length === 0 && conflicts.length === 0 && changes.length === 0,
+    issues,
+    conflicts,
+    changedFiles: changes.map((change) => change.file),
+    writtenFiles,
+    changes
+  };
+}
+async function processProjectFiles(options, mode) {
+  const cwd = path3.resolve(options.cwd ?? process.cwd());
+  const config = await loadConfig(cwd, options.configPath);
+  const files = await findProjectFiles(cwd, config, options.staged ?? false);
+  const processed = [];
+  for (const filePath of files) {
+    const source = await fs.readFile(filePath, "utf8");
+    let output = source;
+    const issues = [];
+    const conflicts = [];
+    if (config.imports) {
+      const result = runCleaner(ImportCleaner, mode, { filePath, source: output, config });
+      issues.push(...result.issues);
+      output = result.output ?? output;
+    }
+    if (config.tailwind) {
+      const result = runCleaner(TailwindCleaner, mode, { filePath, source: output, config });
+      issues.push(...result.issues);
+      conflicts.push(...result.conflicts ?? []);
+      output = result.output ?? output;
+    }
+    processed.push({ filePath, source, output, issues, conflicts });
+  }
+  return processed;
+}
+function runCleaner(cleaner, mode, context) {
+  return mode === "check" ? cleaner.check(context) : cleaner.fix(context);
+}
+
+// src/index.ts
 var program = new Command();
-program.name("cleanwind").description("Clean imports and Tailwind CSS class names.").version("0.1.0");
+program.name("cleanwind").description("Clean imports and Tailwind CSS class names.").version("0.1.2");
 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) => {
   const runOptions = toRunOptions(options);
   if (options.write) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cleanwind",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Clean imports and Tailwind CSS class names from the command line.",
   "type": "module",
   "license": "MIT",
@@ -31,11 +31,18 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@cleanwind/core": "0.1.0",
-    "commander": "^12.1.0"
+    "@babel/parser": "^7.26.3",
+    "@babel/types": "^7.26.3",
+    "commander": "^12.1.0",
+    "fast-glob": "^3.3.2",
+    "jiti": "^2.4.2",
+    "magic-string": "^0.30.17"
+  },
+  "devDependencies": {
+    "@cleanwind/core": "workspace:*"
   }
 }