tailwindcss-patch 2.0.4 → 2.0.5-alpha.1

package/README.md

@@ -52,7 +52,7 @@ npx tw-patch install
 tw-patch init
 ```
 
-Then there will be a ts file called `tailwindcss-patch.config.ts` exist in your `cwd`.
+Then there will be a ts file called `tailwindcss-mangle.config.ts` exist in your `cwd`.
 
 ### Extract all class into a json
 
@@ -62,7 +62,7 @@ tw-patch extract
 
 default there will be a json in `.tw-patch/tw-class-list.json` in your project.
 
-you can custom this behavior by config `tailwindcss-patch.config.ts`
+you can custom this behavior by config `tailwindcss-mangle.config.ts`
 
 ### Nodejs
 

package/dist/{index.mjs → cli.js}

@@ -1,35 +1,75 @@
-import fs$1 from 'node:fs/promises';
-import path, { dirname } from 'node:path';
-import fs from 'node:fs';
-import pkg from 'resolve';
-import { gte } from 'semver';
-import * as t from '@babel/types';
-import generate from '@babel/generator';
-import traverse from '@babel/traverse';
-import { parse } from '@babel/parser';
-import postcss from 'postcss';
-import { lilconfig } from 'lilconfig';
-import createJiti from 'jiti';
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_cac = __toESM(require("cac"));
 
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  CacheManager: () => CacheManager,
+  TailwindcssPatcher: () => TailwindcssPatcher,
+  createPatch: () => createPatch,
+  getCacheOptions: () => getCacheOptions,
+  getClassCacheSet: () => getClassCacheSet,
+  getClassCaches: () => getClassCaches,
+  getContexts: () => getContexts,
+  getInstalledPkgJsonPath: () => getInstalledPkgJsonPath,
+  getPatchOptions: () => getPatchOptions,
+  getTailwindcssEntry: () => getTailwindcssEntry,
+  inspectPostcssPlugin: () => inspectPostcssPlugin,
+  inspectProcessTailwindFeaturesReturnContext: () => inspectProcessTailwindFeaturesReturnContext,
+  internalPatch: () => internalPatch,
+  monkeyPatchForExposingContext: () => monkeyPatchForExposingContext
+});
 
-// -- Unbuild CommonJS Shims --
-import __cjs_url__ from 'url';
-import __cjs_path__ from 'path';
-import __cjs_mod__ from 'module';
-const __filename = __cjs_url__.fileURLToPath(import.meta.url);
-const __dirname = __cjs_path__.dirname(__filename);
-const require = __cjs_mod__.createRequire(import.meta.url);
-export * from '@tailwindcss-mangle/config';
+// src/core/tw-patcher.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path5 = require("path");
 
-const { sync } = pkg;
+// src/core/exposeContext.ts
+var import_node_path = __toESM(require("path"));
+var import_node_fs2 = __toESM(require("fs"));
+
+// src/utils.ts
+var import_node_fs = __toESM(require("fs"));
+var import_promises = __toESM(require("fs/promises"));
+var import_resolve = __toESM(require("resolve"));
+var { sync } = import_resolve.default;
 function ensureFileContent(filepaths) {
   if (typeof filepaths === "string") {
     filepaths = [filepaths];
   }
   let content;
   for (const filepath of filepaths) {
-    if (fs.existsSync(filepath)) {
-      content = fs.readFileSync(filepath, {
+    if (import_node_fs.default.existsSync(filepath)) {
+      content = import_node_fs.default.readFileSync(filepath, {
         encoding: "utf8"
       });
       break;
@@ -42,23 +82,24 @@ function requireResolve(id, opts) {
 }
 async function ensureDir(p) {
   try {
-    await fs$1.access(p);
+    await import_promises.default.access(p);
   } catch {
-    await fs$1.mkdir(p, {
+    await import_promises.default.mkdir(p, {
       recursive: true
     });
   }
 }
 
+// src/core/exposeContext.ts
 function getTailwindcssEntry(basedir = process.cwd()) {
   return requireResolve("tailwindcss");
 }
 function getContexts(basedir) {
   const twPath = getTailwindcssEntry(basedir);
-  const distPath = path.dirname(twPath);
-  let injectFilePath = path.join(distPath, "plugin.js");
-  if (!fs.existsSync(injectFilePath)) {
-    injectFilePath = path.join(distPath, "index.js");
+  const distPath = import_node_path.default.dirname(twPath);
+  let injectFilePath = import_node_path.default.join(distPath, "plugin.js");
+  if (!import_node_fs2.default.existsSync(injectFilePath)) {
+    injectFilePath = import_node_path.default.join(distPath, "index.js");
   }
   const mo = require(injectFilePath);
   if (mo.contextRef) {
@@ -86,12 +127,19 @@ function getClassCacheSet(basedir, options) {
   return classSet;
 }
 
-const pkgName = "tailwindcss-patch";
+// src/core/cache.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/constants.ts
+var pkgName = "tailwindcss-patch";
 
+// src/logger.ts
 function log(message, ...optionalParams) {
   return console.log(`[${pkgName}]:` + message, ...optionalParams);
 }
 
+// src/core/cache.ts
 function getCacheOptions(options) {
   let cache;
   switch (typeof options) {
@@ -114,14 +162,15 @@ function getCacheOptions(options) {
   }
   return cache;
 }
-class CacheManager {
+var CacheManager = class {
+  options;
   constructor(options = {}) {
     this.options = this.getOptions(options);
   }
   mkdir(cacheDirectory) {
-    const exists = fs.existsSync(cacheDirectory);
+    const exists = import_node_fs3.default.existsSync(cacheDirectory);
     if (!exists) {
-      fs.mkdirSync(cacheDirectory, {
+      import_node_fs3.default.mkdirSync(cacheDirectory, {
         recursive: true
       });
     }
@@ -129,9 +178,9 @@ class CacheManager {
   }
   getOptions(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const dir = options.dir ?? path.resolve(cwd, "node_modules/.cache", pkgName);
+    const dir = options.dir ?? import_node_path2.default.resolve(cwd, "node_modules/.cache", pkgName);
     const file = options.file ?? "index.json";
-    const filename = path.resolve(dir, file);
+    const filename = import_node_path2.default.resolve(dir, file);
     return {
       cwd,
       dir,
@@ -144,7 +193,7 @@ class CacheManager {
     try {
       const { dir, filename } = this.options;
       this.mkdir(dir);
-      fs.writeFileSync(filename, JSON.stringify([...data], void 0, 2), "utf8");
+      import_node_fs3.default.writeFileSync(filename, JSON.stringify([...data], void 0, 2), "utf8");
       return filename;
     } catch {
       log("write cache file fail!");
@@ -153,21 +202,27 @@ class CacheManager {
   read() {
     const { filename } = this.options;
     try {
-      if (fs.existsSync(filename)) {
-        const data = fs.readFileSync(filename, "utf8");
+      if (import_node_fs3.default.existsSync(filename)) {
+        const data = import_node_fs3.default.readFileSync(filename, "utf8");
         return new Set(JSON.parse(data));
       }
     } catch {
       log("parse cache content fail! path:" + filename);
       try {
-        fs.unlinkSync(filename);
+        import_node_fs3.default.unlinkSync(filename);
       } catch {
         log("delete cache file fail! path:" + filename);
       }
     }
   }
-}
+};
+
+// src/core/runtime-patcher.ts
+var import_node_path3 = __toESM(require("path"));
+var import_node_fs4 = __toESM(require("fs"));
+var import_semver = require("semver");
 
+// ../../node_modules/.pnpm/defu@6.1.2/node_modules/defu/dist/defu.mjs
 function isObject(value) {
   return value !== null && typeof value === "object";
 }
@@ -208,12 +263,33 @@ function createDefu(merger) {
     arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
   );
 }
-const defu = createDefu();
+var defu = createDefu();
+var defuFn = createDefu((object, key, currentValue) => {
+  if (typeof object[key] !== "undefined" && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+var defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
 
+// src/core/inspector.ts
+var t = __toESM(require("@babel/types"));
+
+// src/babel/index.ts
+var import_generator = __toESM(require("@babel/generator"));
+var import_traverse = __toESM(require("@babel/traverse"));
+var import_parser = require("@babel/parser");
+
+// src/core/inspector.ts
 function inspectProcessTailwindFeaturesReturnContext(content) {
-  const ast = parse(content);
+  const ast = (0, import_parser.parse)(content);
   let hasPatched = false;
-  traverse(ast, {
+  (0, import_traverse.default)(ast, {
     FunctionDeclaration(p) {
       const n = p.node;
       if (n.id?.name === "processTailwindFeatures" && n.body.body.length === 1 && t.isReturnStatement(n.body.body[0])) {
@@ -231,17 +307,17 @@ function inspectProcessTailwindFeaturesReturnContext(content) {
     }
   });
   return {
-    code: hasPatched ? content : generate(ast).code,
+    code: hasPatched ? content : (0, import_generator.default)(ast).code,
     hasPatched
   };
 }
 function inspectPostcssPlugin(content) {
-  const ast = parse(content);
+  const ast = (0, import_parser.parse)(content);
   const exportKey = "contextRef";
   const variableName = "contextRef";
   const valueKey = "value";
   let hasPatched = false;
-  traverse(ast, {
+  (0, import_traverse.default)(ast, {
     Program(p) {
       const n = p.node;
       const idx = n.body.findIndex((x) => {
@@ -276,9 +352,9 @@ function inspectPostcssPlugin(content) {
       }
       const n = p.node;
       if (n.id?.name === "tailwindcss" && n.body.body.length === 1 && t.isReturnStatement(n.body.body[0])) {
-        const returnStatement = n.body.body[0];
-        if (t.isObjectExpression(returnStatement.argument) && returnStatement.argument.properties.length === 2) {
-          const properties = returnStatement.argument.properties;
+        const returnStatement2 = n.body.body[0];
+        if (t.isObjectExpression(returnStatement2.argument) && returnStatement2.argument.properties.length === 2) {
+          const properties = returnStatement2.argument.properties;
           if (t.isObjectProperty(properties[0]) && t.isObjectProperty(properties[1])) {
             const keyMatched = t.isIdentifier(properties[0].key) && properties[0].key.name === "postcssPlugin";
             const pluginsMatched = t.isIdentifier(properties[1].key) && properties[1].key.name === "plugins";
@@ -342,17 +418,19 @@ function inspectPostcssPlugin(content) {
     // }
   });
   return {
-    code: hasPatched ? content : generate(ast).code,
+    code: hasPatched ? content : (0, import_generator.default)(ast).code,
     hasPatched
   };
 }
 
+// src/defaults.ts
 function getDefaultPatchOptions() {
   return {
     overwrite: true
   };
 }
 
+// src/core/runtime-patcher.ts
 function getInstalledPkgJsonPath(options = {}) {
   try {
     const tmpJsonPath = requireResolve(`tailwindcss/package.json`, {
@@ -385,26 +463,26 @@ function createPatch(opt) {
   };
 }
 function monkeyPatchForExposingContext(twDir, opt) {
-  const processTailwindFeaturesFilePath = path.resolve(twDir, "lib/processTailwindFeatures.js");
+  const processTailwindFeaturesFilePath = import_node_path3.default.resolve(twDir, "lib/processTailwindFeatures.js");
   const processTailwindFeaturesContent = ensureFileContent(processTailwindFeaturesFilePath);
   const result = {};
   if (processTailwindFeaturesContent) {
     const { code, hasPatched } = inspectProcessTailwindFeaturesReturnContext(processTailwindFeaturesContent);
     if (!hasPatched && opt.overwrite) {
-      fs.writeFileSync(processTailwindFeaturesFilePath, code, {
+      import_node_fs4.default.writeFileSync(processTailwindFeaturesFilePath, code, {
         encoding: "utf8"
       });
       console.log("patch tailwindcss processTailwindFeatures for return content successfully!");
     }
     result.processTailwindFeatures = code;
   }
-  const pluginFilePath = path.resolve(twDir, "lib/plugin.js");
-  const indexFilePath = path.resolve(twDir, "lib/index.js");
+  const pluginFilePath = import_node_path3.default.resolve(twDir, "lib/plugin.js");
+  const indexFilePath = import_node_path3.default.resolve(twDir, "lib/index.js");
   const pluginContent = ensureFileContent([pluginFilePath, indexFilePath]);
   if (pluginContent) {
     const { code, hasPatched } = inspectPostcssPlugin(pluginContent);
     if (!hasPatched && opt.overwrite) {
-      fs.writeFileSync(pluginFilePath, code, {
+      import_node_fs4.default.writeFileSync(pluginFilePath, code, {
         encoding: "utf8"
       });
       console.log("patch tailwindcss for expose runtime content successfully!");
@@ -417,8 +495,8 @@ function monkeyPatchForExposingContext(twDir, opt) {
 function internalPatch(pkgJsonPath, options) {
   if (pkgJsonPath) {
     const pkgJson = require(pkgJsonPath);
-    const twDir = path.dirname(pkgJsonPath);
-    if (gte(pkgJson.version, "3.0.0")) {
+    const twDir = import_node_path3.default.dirname(pkgJsonPath);
+    if ((0, import_semver.gte)(pkgJson.version, "3.0.0")) {
       options.version = pkgJson.version;
       const result = monkeyPatchForExposingContext(twDir, options);
       return result;
@@ -426,13 +504,18 @@ function internalPatch(pkgJsonPath, options) {
   }
 }
 
-const jiti = createJiti(__filename);
+// src/core/postcss.ts
+var import_node_path4 = __toESM(require("path"));
+var import_postcss = __toESM(require("postcss"));
+var import_lilconfig = require("lilconfig");
+var import_jiti = __toESM(require("jiti"));
+var jiti = (0, import_jiti.default)(__filename);
 async function processTailwindcss(options) {
   options.cwd = options.cwd ?? process.cwd();
   let config = options.config;
-  if (!(typeof options.config === "string" && path.isAbsolute(options.config))) {
+  if (!(typeof options.config === "string" && import_node_path4.default.isAbsolute(options.config))) {
     const moduleName = "tailwind";
-    const result = await lilconfig("tailwindcss", {
+    const result = await (0, import_lilconfig.lilconfig)("tailwindcss", {
       searchPlaces: [`${moduleName}.config.js`, `${moduleName}.config.cjs`],
       loaders: {
         // 默认支持 js 和 cjs 2种格式
@@ -447,7 +530,7 @@ async function processTailwindcss(options) {
     }
     config = result.filepath;
   }
-  return await postcss([
+  return await (0, import_postcss.default)([
     require("tailwindcss")({
       config
     })
@@ -456,7 +539,13 @@ async function processTailwindcss(options) {
   });
 }
 
-class TailwindcssPatcher {
+// src/core/tw-patcher.ts
+var TailwindcssPatcher = class {
+  rawOptions;
+  cacheOptions;
+  patchOptions;
+  patch;
+  cacheManager;
   constructor(options = {}) {
     this.rawOptions = options;
     this.cacheOptions = getCacheOptions(options.cache);
@@ -511,13 +600,44 @@ class TailwindcssPatcher {
         removeUniversalSelector
       });
       if (filename) {
-        await ensureDir(dirname(filename));
+        await ensureDir((0, import_node_path5.dirname)(filename));
         const classList = [...set];
-        await fs$1.writeFile(filename, JSON.stringify(classList, null, loose ? 2 : void 0), "utf8");
+        await import_promises2.default.writeFile(filename, JSON.stringify(classList, null, loose ? 2 : void 0), "utf8");
         return filename;
       }
     }
   }
-}
+};
+
+// src/core/config.ts
+var config_exports = {};
+__reExport(config_exports, require("@tailwindcss-mangle/config"));
 
-export { CacheManager, TailwindcssPatcher, createPatch, ensureDir, ensureFileContent, getCacheOptions, getClassCacheSet, getClassCaches, getContexts, getInstalledPkgJsonPath, getPatchOptions, getTailwindcssEntry, inspectPostcssPlugin, inspectProcessTailwindFeaturesReturnContext, internalPatch, monkeyPatchForExposingContext, requireResolve };
+// src/core/index.ts
+__reExport(core_exports, config_exports);
+
+// src/cli.ts
+function init() {
+  const cwd = process.cwd();
+  return (0, core_exports.initConfig)(cwd);
+}
+var cli = (0, import_cac.default)();
+cli.command("install", "patch install").action(() => {
+  const opt = getPatchOptions();
+  const patch = createPatch(opt);
+  patch();
+});
+cli.command("init").action(async () => {
+  await init();
+  console.log(`\u2728 ${core_exports.configName}.config.ts initialized!`);
+});
+cli.command("extract").action(async () => {
+  const { config } = await (0, core_exports.getConfig)();
+  if (config) {
+    const twPatcher = new TailwindcssPatcher();
+    const p = await twPatcher.extract(config.patch);
+    console.log("\u2728 tailwindcss-patch extract success! file path:\n" + p);
+  }
+});
+cli.help();
+cli.parse();