domflax 0.1.0 → 0.1.2

package/dist/cli.js

@@ -5,14 +5,14 @@ import {
   createJsxBackend,
   createJsxFrontend,
   createTailwindResolver
-} from "./chunk-4HHISSMR.js";
+} from "./chunk-DNHOGPYV.js";
 import {
   buildSelectorIndex,
   createSyntheticSink,
   normalizer,
   runPasses,
   syncClassesFromComputed
-} from "./chunk-77SLHRN6.js";
+} from "./chunk-DWLB7FRR.js";
 import {
   __commonJS,
   __toESM,
@@ -156,8 +156,7 @@ init_esm_shims();
 // ../cli/src/index.ts
 init_esm_shims();
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import * as path3 from "path";
-import { fileURLToPath } from "url";
+import * as path4 from "path";
 
 // ../cli/src/options.ts
 init_esm_shims();
@@ -358,87 +357,91 @@ function createTransform(options) {
   const projectRoot = options.projectRoot ?? process.cwd();
   const resolver = buildResolver(options.provider, options.css, projectRoot);
   const patterns = selectPatterns(options.passes);
+  function prepare(code, id, kind, gate) {
+    const parsed = createJsxFrontend().parse(code, {
+      id,
+      kind,
+      resolver,
+      normalizer,
+      config: {},
+      onDiagnostic: () => {
+      }
+    });
+    const doc = parsed.doc;
+    const nodesIn = doc.nodes.size;
+    for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;
+    const ctx = {
+      doc,
+      safetyCeiling: options.safety,
+      normalizer,
+      // Real CSS-selector-safety index from the active resolver (custom-CSS reports combinator /
+      // structural-pseudo coupling; Tailwind has none → null index, behaviour unchanged).
+      selectors: buildSelectorIndex(doc, resolver),
+      resolver,
+      gate
+    };
+    return { doc, ctx, passes: buildPasses(patterns), nodesIn };
+  }
+  function finish(code, optimized, id, nodesIn) {
+    syncClassesFromComputed(optimized, resolver, normalizer);
+    const printed = createJsxBackend().print(
+      optimized,
+      { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
+      { normalizer, resolver, sink: createSyntheticSink(), eol: "\n", onDiagnostic: () => {
+      } }
+    );
+    const out = printed.code;
+    const nodesOut = optimized.nodes.size;
+    const classesBefore = countClassTokens(code);
+    const classesAfter = countClassTokens(out);
+    return {
+      code: out,
+      changed: out !== code,
+      passthrough: false,
+      stats: {
+        nodesIn,
+        nodesOut,
+        nodesRemoved: Math.max(0, nodesIn - nodesOut),
+        classesBefore,
+        classesAfter,
+        classesSaved: Math.max(0, classesBefore - classesAfter),
+        bytesBefore: bytes(code),
+        bytesAfter: bytes(out),
+        bytesSaved: bytes(code) - bytes(out)
+      }
+    };
+  }
   return {
     resolver,
     transformFile(code, id) {
       const kind = jsxKindOf(id);
       if (kind === null) return passthroughResult(code);
-      const parsed = createJsxFrontend().parse(code, {
-        id,
-        kind,
-        resolver,
-        normalizer,
-        config: {},
-        onDiagnostic: () => {
-        }
-      });
-      const doc = parsed.doc;
-      const nodesIn = doc.nodes.size;
-      for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;
-      const ctx = {
-        doc,
-        safetyCeiling: options.safety,
-        normalizer,
-        // Real CSS-selector-safety index from the active resolver (custom-CSS reports combinator /
-        // structural-pseudo coupling; Tailwind has none → null index, behaviour unchanged).
-        selectors: buildSelectorIndex(doc, resolver),
-        resolver
-      };
-      const { doc: optimized } = runPasses(doc, buildPasses(patterns), ctx);
-      syncClassesFromComputed(optimized, resolver, normalizer);
-      const printed = createJsxBackend().print(
-        optimized,
-        { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
-        {
-          normalizer,
-          resolver,
-          sink: createSyntheticSink(),
-          eol: "\n",
-          onDiagnostic: () => {
-          }
-        }
-      );
-      const out = printed.code;
-      const nodesOut = optimized.nodes.size;
-      const classesBefore = countClassTokens(code);
-      const classesAfter = countClassTokens(out);
-      return {
-        code: out,
-        changed: out !== code,
-        passthrough: false,
-        stats: {
-          nodesIn,
-          nodesOut,
-          nodesRemoved: Math.max(0, nodesIn - nodesOut),
-          classesBefore,
-          classesAfter,
-          classesSaved: Math.max(0, classesBefore - classesAfter),
-          bytesBefore: bytes(code),
-          bytesAfter: bytes(out),
-          bytesSaved: bytes(code) - bytes(out)
-        }
-      };
+      const { doc, ctx, passes, nodesIn } = prepare(code, id, kind, "provably-safe");
+      const { doc: optimized } = runPasses(doc, passes, ctx);
+      return finish(code, optimized, id, nodesIn);
     }
   };
 }
-function builtinPatternNames() {
-  return builtinPatterns.map((p2) => p2.name);
-}
 
 // ../cli/src/walk.ts
 init_esm_shims();
 import * as fs from "fs";
 import * as path2 from "path";
-var SUPPORTED_EXTS = [".jsx", ".tsx", ".html", ".htm"];
+var SUPPORTED_EXTS = [".jsx", ".tsx"];
+var HTML_EXTS = [".html", ".htm"];
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "domflax-out"]);
 function isSupported(file) {
   const lower = file.toLowerCase();
   return SUPPORTED_EXTS.some((ext) => lower.endsWith(ext));
 }
+function isHtml(file) {
+  const lower = file.toLowerCase();
+  return HTML_EXTS.some((ext) => lower.endsWith(ext));
+}
 function hasGlobMagic(p2) {
   return /[*?[\]{}]/.test(p2);
 }
-function walkDir(dir, out) {
+function walkDir(dir, out, counts) {
   let entries;
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -449,9 +452,10 @@ function walkDir(dir, out) {
     const full = path2.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
-      walkDir(full, out);
-    } else if (entry.isFile() && isSupported(entry.name)) {
-      out.push(full);
+      walkDir(full, out, counts);
+    } else if (entry.isFile()) {
+      if (isSupported(entry.name)) out.push(full);
+      else if (isHtml(entry.name)) counts.html += 1;
     }
   }
 }
@@ -462,6 +466,7 @@ function globSyncMaybe() {
 function discoverInputs(paths) {
   const files = [];
   const warnings = [];
+  const counts = { html: 0 };
   const seen = /* @__PURE__ */ new Set();
   const push = (f) => {
     const abs = path2.resolve(f);
@@ -485,11 +490,13 @@ function discoverInputs(paths) {
       stat = null;
     }
     if (stat?.isDirectory()) {
-      walkDir(path2.resolve(p2), files);
+      walkDir(path2.resolve(p2), files, counts);
       continue;
     }
     if (stat?.isFile()) {
-      push(p2);
+      if (isSupported(p2)) push(p2);
+      else if (isHtml(p2)) counts.html += 1;
+      else warnings.push(`unsupported file type, skipped: ${p2}`);
       continue;
     }
     if (hasGlobMagic(p2)) {
@@ -498,9 +505,11 @@ function discoverInputs(paths) {
         warnings.push(`glob not supported on this Node version, skipped: ${p2}`);
         continue;
       }
-      const matches = glob(p2).filter(isSupported);
-      if (matches.length === 0) warnings.push(`no files matched: ${p2}`);
-      for (const m2 of matches) push(m2);
+      const matched = glob(p2);
+      const supported = matched.filter(isSupported);
+      counts.html += matched.filter(isHtml).length;
+      if (supported.length === 0) warnings.push(`no .jsx/.tsx files matched: ${p2}`);
+      for (const m2 of supported) push(m2);
       continue;
     }
     warnings.push(`no such file or directory: ${p2}`);
@@ -514,6 +523,11 @@ function discoverInputs(paths) {
       deduped.push(abs);
     }
   }
+  if (deduped.length === 0 && counts.html > 0) {
+    warnings.push(
+      `found ${counts.html} .html file${counts.html === 1 ? "" : "s"} but HTML optimization isn't supported yet (domflax currently optimizes .jsx/.tsx source; HTML is on the roadmap: https://github.com/Krishnesh-Mishra/domflax#roadmap).`
+    );
+  }
   return { files: deduped, inputRoot, warnings };
 }
 
@@ -1098,19 +1112,122 @@ ${import_picocolors2.default.gray(d2)}  ${t}
 };
 var J2 = `${import_picocolors2.default.gray(o)}  `;
 
+// ../cli/src/detect.ts
+init_esm_shims();
+import * as fs2 from "fs";
+import * as path3 from "path";
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  ".git",
+  "domflax-out"
+]);
+var COMMON_INPUT_DIRS = ["src", "app", "components", "pages", "lib", "ui", "public"];
+var CSS_FILE_CAP = 200;
+var DEFAULT_CSS_DEPTH = 10;
+function toRelative(root, abs) {
+  const rel = path3.relative(root, abs);
+  return rel.split(path3.sep).join("/");
+}
+function detectCssFiles(root, scanRoots = [], maxDepth = DEFAULT_CSS_DEPTH) {
+  const base = path3.resolve(root);
+  const found = /* @__PURE__ */ new Map();
+  let capped = false;
+  const walk = (dir, depth) => {
+    if (capped || depth > maxDepth) return;
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS2.has(entry.name)) continue;
+        walk(full, depth + 1);
+        if (capped) return;
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".css")) {
+        const abs = path3.resolve(full);
+        if (!found.has(abs)) {
+          found.set(abs, toRelative(base, abs));
+          if (found.size >= CSS_FILE_CAP) {
+            capped = true;
+            return;
+          }
+        }
+      }
+    }
+  };
+  walk(base, 0);
+  for (const r2 of scanRoots) {
+    if (capped) break;
+    const abs = path3.resolve(r2);
+    if (abs !== base) walk(abs, 0);
+  }
+  const list = [...found.values()].sort((a, b3) => a.localeCompare(b3));
+  if (capped) {
+    console.error(`domflax: more than ${CSS_FILE_CAP} CSS files found; showing the first ${CSS_FILE_CAP}.`);
+  }
+  return list;
+}
+function detectInputDirs(root) {
+  const resolved = path3.resolve(root);
+  return COMMON_INPUT_DIRS.filter((name) => {
+    try {
+      return fs2.statSync(path3.join(resolved, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
 // ../cli/src/wizard.ts
+var OTHER_INPUT = "\0domflax.other";
 var WIZARD_CANCELLED = /* @__PURE__ */ Symbol("domflax.wizard.cancelled");
 function cancelled(value) {
   return pD(value);
 }
 async function runWizard(base) {
   Ie("domflax \u2014 optimize your markup");
-  const pathInput = await he({
-    message: "Which folder, glob, or file should domflax optimize?",
-    placeholder: "src",
-    defaultValue: "src"
-  });
-  if (cancelled(pathInput)) return done();
+  const root = base.projectRoot ?? process.cwd();
+  const detectedInputs = detectInputDirs(root);
+  let inputPath;
+  if (detectedInputs.length > 0) {
+    const defaultInput = detectedInputs.includes("src") ? "src" : detectedInputs[0];
+    const choice = await ve({
+      message: "Which folder should domflax optimize?",
+      options: [
+        ...detectedInputs.map((dir) => ({ value: dir, label: dir, hint: "detected" })),
+        { value: OTHER_INPUT, label: "Other (type a path)\u2026" }
+      ],
+      initialValue: defaultInput
+    });
+    if (cancelled(choice)) return done();
+    if (choice === OTHER_INPUT) {
+      const typed = await he({
+        message: "Which folder, glob, or file should domflax optimize?",
+        placeholder: "src",
+        defaultValue: "src"
+      });
+      if (cancelled(typed)) return done();
+      inputPath = String(typed);
+    } else {
+      inputPath = String(choice);
+    }
+  } else {
+    const typed = await he({
+      message: "Which folder, glob, or file should domflax optimize?",
+      placeholder: "src",
+      defaultValue: "src"
+    });
+    if (cancelled(typed)) return done();
+    inputPath = String(typed);
+  }
   const outputMode = await ve({
     message: "Where should the optimized files go?",
     options: [
@@ -1138,15 +1255,6 @@ async function runWizard(base) {
   } else if (outputMode === "overwrite") {
     dangerouslyOverwriteSource = true;
   }
-  const allPasses = builtinPatternNames();
-  const passSelection = await fe({
-    message: "Which optimization passes should run?",
-    options: allPasses.map((name) => ({ value: name, label: name })),
-    initialValues: [...allPasses],
-    required: true
-  });
-  if (cancelled(passSelection)) return done();
-  const passes = passSelection;
   const provider = await ve({
     message: "How should class names resolve to styles?",
     options: [
@@ -1159,23 +1267,35 @@ async function runWizard(base) {
   if (cancelled(provider)) return done();
   let css = base.css;
   if (provider === "custom") {
-    const cssInput = await he({
-      message: "CSS files (space-separated):",
-      placeholder: "src/styles.css"
-    });
-    if (cancelled(cssInput)) return done();
-    css = String(cssInput).split(/\s+/).filter((s) => s.length > 0);
+    const detectedCss = detectCssFiles(root, [inputPath]);
+    if (detectedCss.length > 0) {
+      const picked = await fe({
+        message: "Which CSS files should resolve your classes? (all detected files are pre-selected)",
+        options: detectedCss.map((file) => ({ value: file, label: file })),
+        initialValues: [...detectedCss],
+        required: false
+      });
+      if (cancelled(picked)) return done();
+      css = picked;
+    } else {
+      const cssInput = await he({
+        message: "CSS files (space-separated):",
+        placeholder: "src/styles.css"
+      });
+      if (cancelled(cssInput)) return done();
+      css = String(cssInput).split(/\s+/).filter((s) => s.length > 0);
+    }
   }
   Se("Ready \u2014 running domflax.");
   return {
     ...base,
-    paths: [String(pathInput)],
+    paths: [inputPath],
     out,
     provider,
     css,
     dryRun,
     dangerouslyOverwriteSource,
-    passes: passes.length === allPasses.length ? null : passes,
+    passes: null,
     safety: base.safety ?? DEFAULT_SAFETY
   };
   function done() {
@@ -1201,11 +1321,11 @@ function printReport(totals) {
   console.log(`  classes saved   : ${totals.classesSaved}`);
   console.log(`  bytes saved     : ${totals.bytesSaved}`);
 }
-function execute(options) {
+async function execute(options) {
   const { files, inputRoot, warnings } = discoverInputs(options.paths);
   for (const w2 of warnings) console.error(`domflax: ${w2}`);
   if (files.length === 0) {
-    console.error("domflax: no .jsx/.tsx/.html files found for the given paths");
+    console.error("domflax: no .jsx/.tsx files found for the given paths");
     return { exitCode: 1 };
   }
   const projectRoot = options.projectRoot ?? process.cwd();
@@ -1231,7 +1351,7 @@ function execute(options) {
     const result = transform.transformFile(code, file);
     addStats(totals, result.stats, result.changed);
     if (options.dryRun) {
-      const rel = path3.relative(inputRoot, file) || path3.basename(file);
+      const rel = path4.relative(inputRoot, file) || path4.basename(file);
       if (result.changed) console.log(unifiedDiff(code, result.code, rel));
       else if (!options.report) console.log(`  (unchanged) ${rel}`);
       continue;
@@ -1244,16 +1364,28 @@ function execute(options) {
       continue;
     }
     try {
-      mkdirSync(path3.dirname(target.value), { recursive: true });
+      mkdirSync(path4.dirname(target.value), { recursive: true });
       writeFileSync(target.value, result.code, "utf8");
-      console.log(`domflax: wrote ${path3.relative(process.cwd(), target.value) || target.value}`);
+      console.log(`domflax: wrote ${path4.relative(process.cwd(), target.value) || target.value}`);
     } catch (err) {
       console.error(`domflax: cannot write ${target.value}: ${String(err?.message ?? err)}`);
       failures += 1;
     }
   }
+  if (options.dryRun) {
+    console.log("\ndomflax: dry run \u2014 no files were written.");
+  } else if (totals.changed === 0) {
+    console.log(
+      `
+domflax: processed ${totals.files} file${totals.files === 1 ? "" : "s"} \u2014 nothing to optimize (0 changed).`
+    );
+  } else {
+    console.log(
+      `
+domflax: optimized ${totals.changed} of ${totals.files} file${totals.files === 1 ? "" : "s"} (${totals.nodesRemoved} nodes removed, ${totals.classesSaved} classes saved, ${totals.bytesSaved} bytes saved).`
+    );
+  }
   if (options.report) printReport(totals);
-  if (options.dryRun) console.log("\ndomflax: dry run \u2014 no files were written.");
   return { exitCode: failures > 0 ? 1 : 0 };
 }
 async function main(argv = process.argv.slice(2)) {
@@ -1283,27 +1415,13 @@ async function main(argv = process.argv.slice(2)) {
     return;
   }
   try {
-    const result = execute(options);
+    const result = await execute(options);
     process.exitCode = result.exitCode;
   } catch (err) {
     console.error(`domflax: ${err instanceof Error ? err.message : String(err)}`);
     process.exitCode = 1;
   }
 }
-function isMainEntry() {
-  const entry = process.argv[1];
-  if (entry === void 0) return false;
-  try {
-    const self = path3.resolve(fileURLToPath(import.meta.url));
-    const argv = path3.resolve(entry);
-    return process.platform === "win32" ? self.toLowerCase() === argv.toLowerCase() : self === argv;
-  } catch {
-    return false;
-  }
-}
-if (isMainEntry()) {
-  void main();
-}
 
 // src/cli.ts
 main(process.argv.slice(2));