weapp-tailwindcss 4.7.2 → 4.7.3

package/dist/cli.js

@@ -1,31 +1,399 @@
-"use strict"; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+"use strict"; function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 var _chunkOXASK55Qjs = require('./chunk-OXASK55Q.js');
 
 
 
-var _chunkFPDJ3BCMjs = require('./chunk-FPDJ3BCM.js');
+var _chunkJTGVWJ3Zjs = require('./chunk-JTGVWJ3Z.js');
 require('./chunk-DWAEHRHN.js');
-require('./chunk-OPTIAB5G.js');
+require('./chunk-SIZNRUIV.js');
 require('./chunk-WXBFAARR.js');
-require('./chunk-UW3WHSZ5.js');
-require('./chunk-QXSBMK2W.js');
+
+
+var _chunkUW3WHSZ5js = require('./chunk-UW3WHSZ5.js');
+
+
+
+var _chunkR7GWRQDJjs = require('./chunk-R7GWRQDJ.js');
 
 // src/cli.ts
+var _promises = require('fs/promises');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _cac = require('cac'); var _cac2 = _interopRequireDefault(_cac);
 var _semver = require('semver'); var _semver2 = _interopRequireDefault(_semver);
+var _tailwindcsspatch = require('tailwindcss-patch');
+
+// src/cli/config.ts
+var _module = require('module');
+var MODULE_ID = "@tailwindcss-mangle/config";
+var cachedRequire;
+function getNodeRequire() {
+  if (cachedRequire) {
+    return cachedRequire;
+  }
+  if (typeof _chunkR7GWRQDJjs.__require === "function") {
+    cachedRequire = _chunkR7GWRQDJjs.__require;
+    return cachedRequire;
+  }
+  try {
+    cachedRequire = _module.createRequire.call(void 0, _chunkR7GWRQDJjs.importMetaUrl);
+  } catch (e) {
+    cachedRequire = void 0;
+  }
+  return cachedRequire;
+}
+async function tryDynamicImport(moduleId) {
+  try {
+    return await Promise.resolve().then(() => _interopRequireWildcard(require(moduleId)));
+  } catch (e2) {
+    return void 0;
+  }
+}
+function tryRequire(moduleId) {
+  const nodeRequire = getNodeRequire();
+  if (!nodeRequire) {
+    return void 0;
+  }
+  try {
+    return nodeRequire(moduleId);
+  } catch (e3) {
+    return void 0;
+  }
+}
+function isValidModule(mod) {
+  return Boolean(mod) && typeof mod.initConfig === "function" && typeof mod.CONFIG_NAME === "string";
+}
+async function loadTailwindcssMangleConfig() {
+  const mod = await _asyncNullishCoalesce(await tryDynamicImport(MODULE_ID), async () => ( tryRequire(MODULE_ID)));
+  return isValidModule(mod) ? mod : void 0;
+}
+
+// src/cli/context.ts
+
+
+function mergeTailwindcssPatcherOptions(overrides, current) {
+  if (!current) {
+    return overrides;
+  }
+  return _chunkUW3WHSZ5js.defuOverrideArray.call(void 0, overrides, current);
+}
+function resolveEntry(entry, cwd) {
+  if (_path2.default.isAbsolute(entry)) {
+    return _path2.default.normalize(entry);
+  }
+  const base = _nullishCoalesce(cwd, () => ( _process2.default.cwd()));
+  return _path2.default.normalize(_path2.default.resolve(base, entry));
+}
+function buildTailwindcssPatcherOptions(overrides) {
+  if (!overrides) {
+    return void 0;
+  }
+  const filtered = {};
+  if (overrides.cwd) {
+    filtered.cwd = overrides.cwd;
+  }
+  if (overrides.output) {
+    const output = {};
+    if (overrides.output.file) {
+      output.file = overrides.output.file;
+    }
+    if (overrides.output.format) {
+      output.format = overrides.output.format;
+    }
+    if (Object.keys(output).length > 0) {
+      filtered.output = output;
+    }
+  }
+  return Object.keys(filtered).length > 0 ? filtered : void 0;
+}
+function createCliContext(overrides, resolvedCwd) {
+  const userOptions = {
+    ..._nullishCoalesce(overrides, () => ( {}))
+  };
+  if (resolvedCwd) {
+    if (!userOptions.tailwindcssBasedir) {
+      userOptions.tailwindcssBasedir = resolvedCwd;
+    }
+    const cwdOptions = { cwd: resolvedCwd };
+    const current = userOptions.tailwindcssPatcherOptions;
+    userOptions.tailwindcssPatcherOptions = mergeTailwindcssPatcherOptions(
+      cwdOptions,
+      current
+    );
+  }
+  return _chunkJTGVWJ3Zjs.getCompilerContext.call(void 0, userOptions);
+}
+function formatOutputPath(target, baseDir) {
+  const root = _nullishCoalesce(baseDir, () => ( _process2.default.cwd()));
+  const relative = _path2.default.relative(root, target);
+  if (!relative) {
+    return ".";
+  }
+  if (relative.startsWith("..")) {
+    return _path2.default.normalize(target);
+  }
+  return relative.startsWith(".") ? relative : `.${_path2.default.sep}${relative}`;
+}
+
+// src/cli/helpers.ts
+
+
+
+function readStringOption(flag, value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError(`Option "--${flag}" expects a string value.`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new TypeError(`Option "--${flag}" expects a non-empty value.`);
+  }
+  return trimmed;
+}
+function normalizeTokenFormat(format) {
+  switch (format) {
+    case "json":
+    case "lines":
+    case "grouped-json":
+      return format;
+    default:
+      return "json";
+  }
+}
+function normalizeExtractFormat(format) {
+  if (!format) {
+    return void 0;
+  }
+  if (format === "json" || format === "lines") {
+    return format;
+  }
+  return void 0;
+}
+function toBoolean(value, fallback) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value === "true") {
+      return true;
+    }
+    if (value === "false") {
+      return false;
+    }
+  }
+  if (value == null) {
+    return fallback;
+  }
+  return Boolean(value);
+}
+function resolveCliCwd(value) {
+  const raw = readStringOption("cwd", value);
+  if (!raw) {
+    return void 0;
+  }
+  return _path2.default.isAbsolute(raw) ? _path2.default.normalize(raw) : _path2.default.resolve(_process2.default.cwd(), raw);
+}
+async function ensureDir(dir) {
+  await _promises.mkdir.call(void 0, dir, { recursive: true });
+}
+function handleCliError(error) {
+  if (error instanceof Error) {
+    _chunkOXASK55Qjs.logger.error(error.message);
+    if (error.stack && _process2.default.env.WEAPP_TW_DEBUG === "1") {
+      _chunkOXASK55Qjs.logger.error(error.stack);
+    }
+  } else {
+    _chunkOXASK55Qjs.logger.error(String(error));
+  }
+}
+function commandAction(handler) {
+  return async (...args) => {
+    try {
+      await handler(...args);
+    } catch (error) {
+      handleCliError(error);
+      _process2.default.exitCode = 1;
+    }
+  };
+}
+
+// src/cli/tokens.ts
+
+async function collectTailwindTokens(patcher) {
+  const candidate = patcher;
+  if (candidate && typeof candidate.collectContentTokens === "function") {
+    return candidate.collectContentTokens();
+  }
+  throw new Error("The current Tailwind CSS patcher does not support token collection.");
+}
+function formatTokenLine(entry) {
+  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
+}
+function formatGroupedPreview(map, limit = 3) {
+  const files = Object.keys(map);
+  if (files.length === 0) {
+    return { preview: "", moreFiles: 0 };
+  }
+  const lines = files.slice(0, limit).map((file) => {
+    const tokens = map[file];
+    const samples = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
+    const suffix = tokens.length > 3 ? ", ..." : "";
+    return `${file}: ${tokens.length} tokens (${samples}${suffix})`;
+  });
+  const moreFiles = files.length > limit ? files.length - limit : 0;
+  return {
+    preview: lines.join("\n"),
+    moreFiles
+  };
+}
+function logTokenPreview(report, format, groupKey) {
+  if (format === "lines") {
+    const preview = report.entries.slice(0, 5).map(formatTokenLine);
+    if (preview.length > 0) {
+      _chunkOXASK55Qjs.logger.log("");
+      for (const line of preview) {
+        _chunkOXASK55Qjs.logger.info(line);
+      }
+      if (report.entries.length > 5) {
+        _chunkOXASK55Qjs.logger.info(`...and ${report.entries.length - 5} more.`);
+      }
+    }
+    return;
+  }
+  if (format === "grouped-json") {
+    const grouped = _tailwindcsspatch.groupTokensByFile.call(void 0, report, {
+      key: groupKey,
+      stripAbsolutePaths: groupKey !== "absolute"
+    });
+    const { preview, moreFiles } = formatGroupedPreview(grouped);
+    if (preview) {
+      _chunkOXASK55Qjs.logger.log("");
+      _chunkOXASK55Qjs.logger.info(preview);
+      if (moreFiles > 0) {
+        _chunkOXASK55Qjs.logger.info(`...and ${moreFiles} more files.`);
+      }
+    }
+    return;
+  }
+  const previewEntries = report.entries.slice(0, 3);
+  if (previewEntries.length > 0) {
+    _chunkOXASK55Qjs.logger.log("");
+    _chunkOXASK55Qjs.logger.info(JSON.stringify(previewEntries, null, 2));
+  }
+}
+
+// src/cli.ts
 _process2.default.title = "node (weapp-tailwindcss)";
-var args = _process2.default.argv.slice(2);
-if (_semver2.default.lt(_process2.default.versions.node, _chunkFPDJ3BCMjs.WEAPP_TW_REQUIRED_NODE_VERSION)) {
+if (_semver2.default.lt(_process2.default.versions.node, _chunkJTGVWJ3Zjs.WEAPP_TW_REQUIRED_NODE_VERSION)) {
   _chunkOXASK55Qjs.logger.warn(
-    `You are using Node.js ${_process2.default.versions.node}. For weapp-tailwindcss, Node.js version >= v${_chunkFPDJ3BCMjs.WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
+    `You are using Node.js ${_process2.default.versions.node}. For weapp-tailwindcss, Node.js version >= v${_chunkJTGVWJ3Zjs.WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
   );
 }
-var command = args[0];
-async function run() {
-  if (command === "patch") {
-    const ctx = _chunkFPDJ3BCMjs.getCompilerContext.call(void 0, );
+var cli = _cac2.default.call(void 0, "weapp-tailwindcss");
+cli.command("patch", "Apply Tailwind CSS runtime patches").alias("install").option("--cwd <dir>", "Working directory").action(
+  commandAction(async (options) => {
+    const resolvedCwd = resolveCliCwd(options.cwd);
+    const ctx = createCliContext(void 0, resolvedCwd);
     await ctx.twPatcher.patch();
-  }
-}
-void run();
+    _chunkOXASK55Qjs.logger.success("Tailwind CSS runtime patched successfully.");
+  })
+);
+cli.command("extract", "Collect generated class names into a cache file").option("--cwd <dir>", "Working directory").option("--output <file>", "Override output file path").option("--format <format>", "Output format (json|lines)").option("--css <file>", "Tailwind CSS entry CSS when using v4").option("--no-write", "Skip writing to disk").action(
+  commandAction(async (options) => {
+    const resolvedCwd = resolveCliCwd(options.cwd);
+    const outputPath = readStringOption("output", options.output);
+    const formatOption = readStringOption("format", options.format);
+    const cssOption = readStringOption("css", options.css);
+    const overrides = {};
+    if (cssOption) {
+      overrides.cssEntries = [resolveEntry(cssOption, resolvedCwd)];
+    }
+    const normalizedFormat = normalizeExtractFormat(formatOption);
+    const outputOverrides = buildTailwindcssPatcherOptions(
+      normalizedFormat || outputPath ? {
+        output: {
+          file: outputPath,
+          format: normalizedFormat
+        }
+      } : void 0
+    );
+    if (outputOverrides) {
+      overrides.tailwindcssPatcherOptions = outputOverrides;
+    }
+    const ctx = createCliContext(overrides, resolvedCwd);
+    const write = toBoolean(options.write, true);
+    const result = await ctx.twPatcher.extract({ write });
+    const classCount = _nullishCoalesce(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _ => _.classList, 'optionalAccess', _2 => _2.length]), () => ( _optionalChain([result, 'optionalAccess', _3 => _3.classSet, 'optionalAccess', _4 => _4.size]))), () => ( 0));
+    if (_optionalChain([result, 'optionalAccess', _5 => _5.filename])) {
+      _chunkOXASK55Qjs.logger.success(`Collected ${classCount} classes -> ${formatOutputPath(result.filename, resolvedCwd)}`);
+    } else {
+      _chunkOXASK55Qjs.logger.success(`Collected ${classCount} classes.`);
+    }
+  })
+);
+cli.command("tokens", "Extract Tailwind tokens with location metadata").option("--cwd <dir>", "Working directory").option("--output <file>", "Override output file path").option("--format <format>", "Output format (json|lines|grouped-json)").option("--group-key <key>", "Grouping key for grouped-json output (relative|absolute)").option("--no-write", "Skip writing to disk").action(
+  commandAction(async (options) => {
+    const resolvedCwd = resolveCliCwd(options.cwd);
+    const outputPath = readStringOption("output", options.output);
+    const formatInput = readStringOption("format", options.format);
+    const groupKeyInput = readStringOption("group-key", options.groupKey);
+    const format = normalizeTokenFormat(_nullishCoalesce(formatInput, () => ( "json")));
+    const groupKey = groupKeyInput === "absolute" ? "absolute" : "relative";
+    const write = toBoolean(options.write, true);
+    const ctx = createCliContext(void 0, resolvedCwd);
+    const report = await collectTailwindTokens(ctx.twPatcher);
+    const baseDir = _nullishCoalesce(resolvedCwd, () => ( _process2.default.cwd()));
+    if (write) {
+      const targetRelative = _nullishCoalesce(outputPath, () => ( ".tw-patch/tw-token-report.json"));
+      const target = _path2.default.resolve(baseDir, targetRelative);
+      await ensureDir(_path2.default.dirname(target));
+      if (format === "json") {
+        await _promises.writeFile.call(void 0, target, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+      } else if (format === "grouped-json") {
+        const grouped = _tailwindcsspatch.groupTokensByFile.call(void 0, report, {
+          key: groupKey,
+          stripAbsolutePaths: groupKey !== "absolute"
+        });
+        await _promises.writeFile.call(void 0, target, `${JSON.stringify(grouped, null, 2)}
+`, "utf8");
+      } else {
+        const lines = report.entries.map(formatTokenLine);
+        await _promises.writeFile.call(void 0, target, `${lines.join("\n")}
+`, "utf8");
+      }
+      _chunkOXASK55Qjs.logger.success(
+        `Collected ${report.entries.length} tokens (${format}) -> ${formatOutputPath(target, resolvedCwd)}`
+      );
+    } else {
+      _chunkOXASK55Qjs.logger.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
+      logTokenPreview(report, format, groupKey);
+    }
+    if (report.skippedFiles.length > 0) {
+      _chunkOXASK55Qjs.logger.warn("Skipped files:");
+      for (const skipped of report.skippedFiles) {
+        _chunkOXASK55Qjs.logger.warn(`  - ${skipped.file} (${skipped.reason})`);
+      }
+    }
+  })
+);
+cli.command("init", "Generate a tailwindcss-patch config file").option("--cwd <dir>", "Working directory").action(
+  commandAction(async (options) => {
+    const resolvedCwd = resolveCliCwd(options.cwd);
+    const moduleResult = await loadTailwindcssMangleConfig();
+    if (!moduleResult) {
+      _chunkOXASK55Qjs.logger.error("Unable to load @tailwindcss-mangle/config. Please install tailwindcss-patch >= 8.2.0.");
+      _process2.default.exitCode = 1;
+      return;
+    }
+    const cwd = _nullishCoalesce(resolvedCwd, () => ( _process2.default.cwd()));
+    await moduleResult.initConfig(cwd);
+    _chunkOXASK55Qjs.logger.success(`${moduleResult.CONFIG_NAME}.config.ts initialized.`);
+  })
+);
+cli.help();
+cli.version(_nullishCoalesce(_process2.default.env.npm_package_version, () => ( "0.0.0")));
+cli.parse();