domflax 0.1.0 → 0.1.1

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,66 +357,68 @@ 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);
     }
   };
 }
@@ -1098,19 +1099,112 @@ ${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;
+function toRelative(root, abs) {
+  const rel = path3.relative(root, abs);
+  return rel.split(path3.sep).join("/");
+}
+function detectCssFiles(root) {
+  const found = [];
+  let capped = false;
+  const walk = (dir) => {
+    if (capped) 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);
+        if (capped) return;
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".css")) {
+        found.push(toRelative(root, full));
+        if (found.length >= CSS_FILE_CAP) {
+          capped = true;
+          return;
+        }
+      }
+    }
+  };
+  walk(path3.resolve(root));
+  found.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 found;
+}
+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: [
@@ -1159,17 +1253,29 @@ 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);
+    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,
@@ -1201,7 +1307,7 @@ 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) {
@@ -1231,7 +1337,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,9 +1350,9 @@ 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;
@@ -1283,27 +1389,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));