tailwindcss-patch 5.0.2 → 6.0.1

package/README.md

@@ -1,10 +1,9 @@
 # tailwindcss-patch
 
-\[[中文(zh-cn)](./README-cn.md)\]
-
 get tailwindcss context at runtime ! extract all classes into file!
 
 - [tailwindcss-patch](#tailwindcss-patch)
+  - [Docs](#docs)
   - [Setup](#setup)
   - [Usage](#usage)
   - [Cli](#cli)
@@ -16,6 +15,10 @@ get tailwindcss context at runtime ! extract all classes into file!
 
 > Nodejs version should >= `16.6.0`
 
+## Docs
+
+[mangle.icebreaker.top](https://mangle.icebreaker.top)
+
 ## Setup
 
 1. Install package

package/bin/tw-patch.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import '../dist/cli.js'
+require('../dist/cli.js')

package/dist/{chunk-LOQK6LST.js → chunk-U2NQZPXE.mjs}

@@ -1,22 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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"));
-
-// src/config.ts
-var config_exports = {};
-__reExport(config_exports, config_star);
-import * as config_star from "@tailwindcss-mangle/config";
-
 // src/logger.ts
 import { createConsola } from "consola";
 var logger = createConsola();
@@ -71,22 +52,21 @@ var CacheManager = class {
       strategy: "merge"
     };
   }
-  write(data) {
+  async write(data) {
     try {
-      const { dir, filename } = this.options;
-      fs.ensureDirSync(dir);
-      fs.outputFileSync(filename, JSON.stringify([...data], void 0, 2), "utf8");
+      const { filename } = this.options;
+      await fs.outputJSON(filename, [...data]);
       return filename;
     } catch {
       logger_default.error("write cache file fail!");
     }
   }
-  read() {
+  async read() {
     const { filename } = this.options;
     try {
-      if (fs.existsSync(filename)) {
-        const data = fs.readFileSync(filename, "utf8");
-        return new Set(JSON.parse(data));
+      if (await fs.exists(filename)) {
+        const data = await fs.readJSON(filename);
+        return new Set(data);
       }
     } catch {
       logger_default.error(`parse cache content fail! path:${filename}`);
@@ -587,14 +567,14 @@ function findAstNode(content, options) {
   let arrayRef;
   let changed = false;
   traverse(ast, {
-    Identifier(path8) {
-      if (path8.node.name === variableName && t3.isVariableDeclarator(path8.parent) && t3.isArrayExpression(path8.parent.init)) {
-        arrayRef = path8.parent.init;
-        const set = new Set(path8.parent.init.elements.map((x) => x.value));
+    Identifier(path7) {
+      if (path7.node.name === variableName && t3.isVariableDeclarator(path7.parent) && t3.isArrayExpression(path7.parent.init)) {
+        arrayRef = path7.parent.init;
+        const set = new Set(path7.parent.init.elements.map((x) => x.value));
         for (let i = 0; i < units.length; i++) {
           const unit = units[i];
           if (!set.has(unit)) {
-            path8.parent.init.elements = path8.parent.init.elements.map((x) => {
+            path7.parent.init.elements = path7.parent.init.elements.map((x) => {
               if (t3.isStringLiteral(x)) {
                 return {
                   type: x?.type,
@@ -603,7 +583,7 @@ function findAstNode(content, options) {
               }
               return x;
             });
-            path8.parent.init.elements.push({
+            path7.parent.init.elements.push({
               type: "StringLiteral",
               value: unit
             });
@@ -688,108 +668,91 @@ function internalPatch(pkgJsonPath, options) {
 
 // src/core/patcher.ts
 import { createRequire as createRequire3 } from "node:module";
-import fs5 from "fs-extra";
-import path7 from "pathe";
+import process5 from "node:process";
+import fs4 from "fs-extra";
+import { getPackageInfoSync } from "local-pkg";
+import path6 from "pathe";
 
 // src/utils.ts
-import fs4 from "fs-extra";
-import path5 from "pathe";
-import pkg from "resolve";
-var { sync } = pkg;
-function requireResolve(id, opts) {
-  return sync(id, opts);
-}
-function searchPackageJSON(dir) {
-  let packageJsonPath;
-  while (true) {
-    if (!dir) {
-      return;
-    }
-    const newDir = path5.dirname(dir);
-    if (newDir === dir) {
-      return;
-    }
-    dir = newDir;
-    packageJsonPath = path5.join(dir, "package.json");
-    if (fs4.existsSync(packageJsonPath)) {
-      break;
-    }
-  }
-  return packageJsonPath;
+function isObject(val) {
+  return val !== null && typeof val === "object" && Array.isArray(val) === false;
 }
-function getTailwindcssEntry(name = "tailwindcss", opts) {
-  return requireResolve(name, opts);
+
+// src/core/candidates.ts
+import process3 from "node:process";
+function importNode() {
+  return import("@tailwindcss/node");
 }
-function getPackageJsonPath(name, options = {}) {
-  const entry = getTailwindcssEntry(name, options);
-  if (!entry) {
-    return;
-  }
-  return searchPackageJSON(entry);
+function importOxide() {
+  return import("@tailwindcss/oxide");
 }
-function getPackageInfoSync(name, options = {}) {
-  const packageJsonPath = getPackageJsonPath(name, options);
-  if (!packageJsonPath) {
-    return;
-  }
-  const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
-  return {
-    name,
-    version: packageJson.version,
-    rootPath: path5.dirname(packageJsonPath),
-    packageJsonPath,
-    packageJson
-  };
+async function extractRawCandidates(sources) {
+  const { Scanner } = await importOxide();
+  const scanner = new Scanner({
+    sources
+  });
+  const candidates = scanner.scan();
+  return candidates;
 }
-function isObject(val) {
-  return val !== null && typeof val === "object" && Array.isArray(val) === false;
+async function extractValidCandidates(options) {
+  const cwd = process3.cwd();
+  const { sources, base, css } = defuOverrideArray(
+    // @ts-ignore
+    options,
+    {
+      css: '@import "tailwindcss";',
+      base: cwd,
+      sources: [
+        {
+          base: cwd,
+          pattern: "**/*"
+        }
+      ]
+    }
+  );
+  const { __unstable__loadDesignSystem } = await importNode();
+  const designSystem = await __unstable__loadDesignSystem(css, { base });
+  const candidates = await extractRawCandidates(sources);
+  const validCandidates = candidates.filter(
+    (rawCandidate) => designSystem.parseCandidate(rawCandidate).length > 0
+  );
+  return validCandidates;
 }
 
 // src/core/postcss.ts
 import { createRequire as createRequire2 } from "node:module";
-import process3 from "node:process";
-import { createJiti } from "jiti";
-import { lilconfig } from "lilconfig";
-import path6 from "pathe";
+import process4 from "node:process";
+import path5 from "pathe";
 import postcss from "postcss";
-var jiti = createJiti(import.meta.url);
+import { loadConfig } from "tailwindcss-config";
 var require3 = createRequire2(import.meta.url);
 async function processTailwindcss(options) {
-  const { config: userConfig, cwd } = defu(options, {
-    cwd: process3.cwd()
+  const { config: userConfig, cwd, majorVersion, postcssPlugin } = defu(options, {
+    cwd: process4.cwd(),
+    majorVersion: 3
   });
   let config = userConfig;
-  if (!(typeof config === "string" && path6.isAbsolute(config))) {
-    const moduleName = "tailwind";
-    const result = await lilconfig("tailwindcss", {
-      searchPlaces: [
-        `${moduleName}.config.js`,
-        `${moduleName}.config.cjs`,
-        `${moduleName}.config.mjs`,
-        `${moduleName}.config.ts`,
-        `${moduleName}.config.cts`,
-        `${moduleName}.config.mts`
-      ],
-      loaders: {
-        // 默认支持 js 和 cjs 2种格式
-        ".js": jiti,
-        ".cjs": jiti,
-        ".mjs": jiti,
-        ".ts": jiti,
-        ".cts": jiti,
-        ".mts": jiti
-      }
-    }).search(cwd);
+  if (!(typeof config === "string" && path5.isAbsolute(config))) {
+    const result = await loadConfig({
+      cwd
+    });
     if (!result) {
       throw new Error(`No TailwindCSS Config found in: ${cwd}`);
     }
     config = result.filepath;
   }
-  const id = requireResolve("tailwindcss", {
-    basedir: cwd
-  });
+  const targetPostcssPlugin = postcssPlugin ?? (majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss");
+  if (majorVersion === 4) {
+    return await postcss([
+      require3(targetPostcssPlugin)({
+        config
+      })
+    ]).process("@import 'tailwindcss';", {
+      from: void 0
+    });
+  }
   return await postcss([
-    require3(id)({
+    require3(targetPostcssPlugin)({
       config
     })
   ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
@@ -812,10 +775,14 @@ var TailwindcssPatcher = class {
     this.cacheOptions = getCacheOptions(options.cache);
     this.patchOptions = getPatchOptions(options.patch);
     this.cacheManager = new CacheManager(this.cacheOptions);
-    this.packageInfo = getPackageInfoSync("tailwindcss", { basedir: this.patchOptions.basedir });
-    if (this.packageInfo && this.packageInfo.version) {
-      this.majorVersion = Number.parseInt(this.packageInfo.version[0]);
+    const packageInfo = getPackageInfoSync("tailwindcss");
+    if (!packageInfo) {
+      throw new Error("tailwindcss not found");
+    }
+    if (packageInfo.version) {
+      this.majorVersion = Number.parseInt(packageInfo.version[0]);
     }
+    this.packageInfo = packageInfo;
     this.patch = () => {
       try {
         return internalPatch(this.packageInfo?.packageJsonPath, this.patchOptions);
@@ -834,14 +801,14 @@ var TailwindcssPatcher = class {
   }
   getContexts() {
     if (this.packageInfo) {
-      const distPath = path7.join(this.packageInfo.rootPath, "lib");
+      const distPath = path6.join(this.packageInfo.rootPath, "lib");
       let injectFilePath;
       if (this.majorVersion === 2) {
-        injectFilePath = path7.join(distPath, "jit/index.js");
-      } else {
-        injectFilePath = path7.join(distPath, "plugin.js");
-        if (!fs5.existsSync(injectFilePath)) {
-          injectFilePath = path7.join(distPath, "index.js");
+        injectFilePath = path6.join(distPath, "jit/index.js");
+      } else if (this.majorVersion === 3) {
+        injectFilePath = path6.join(distPath, "plugin.js");
+        if (!fs4.existsSync(injectFilePath)) {
+          injectFilePath = path6.join(distPath, "index.js");
         }
       }
       if (injectFilePath) {
@@ -857,17 +824,62 @@ var TailwindcssPatcher = class {
     const contexts = this.getContexts();
     return contexts.filter((x) => isObject(x)).map((x) => x.classCache);
   }
-  getClassCacheSet(options) {
-    const classCaches = this.getClassCaches();
+  async getClassCacheSet() {
     const classSet = /* @__PURE__ */ new Set();
-    for (const classCacheMap of classCaches) {
-      const keys = classCacheMap.keys();
-      for (const key of keys) {
-        const v = key.toString();
-        if (options?.removeUniversalSelector && v === "*") {
-          continue;
+    const { output, tailwindcss } = this.patchOptions;
+    if (this.majorVersion === 4) {
+      const { v4 } = tailwindcss ?? {};
+      if (Array.isArray(v4?.cssEntries)) {
+        const results = (await Promise.all(
+          v4.cssEntries.map(async (x) => {
+            if (await fs4.exists(x)) {
+              const css = await fs4.readFile(x, "utf8");
+              return css;
+            }
+            return false;
+          })
+        )).filter((x) => x);
+        for (const css of results) {
+          const candidates = await extractValidCandidates({
+            base: v4?.base,
+            css,
+            sources: v4?.sources?.map((x) => {
+              return {
+                base: x.base ?? v4?.base ?? process5.cwd(),
+                pattern: x.pattern
+              };
+            })
+          });
+          for (const candidate of candidates) {
+            classSet.add(candidate);
+          }
+        }
+      } else {
+        const candidates = await extractValidCandidates({
+          base: v4?.base,
+          css: v4?.css,
+          sources: v4?.sources?.map((x) => {
+            return {
+              base: x.base ?? v4?.base ?? process5.cwd(),
+              pattern: x.pattern
+            };
+          })
+        });
+        for (const candidate of candidates) {
+          classSet.add(candidate);
+        }
+      }
+    } else {
+      const classCaches = this.getClassCaches();
+      for (const classCacheMap of classCaches) {
+        const keys = classCacheMap.keys();
+        for (const key of keys) {
+          const v = key.toString();
+          if (output?.removeUniversalSelector && v === "*") {
+            continue;
+          }
+          classSet.add(v);
         }
-        classSet.add(v);
       }
     }
     return classSet;
@@ -875,15 +887,13 @@ var TailwindcssPatcher = class {
   /**
    * @description 在多个 tailwindcss 上下文时，这个方法将被执行多次，所以策略上应该使用 append
    */
-  getClassSet(options) {
-    const { cacheStrategy = this.cacheOptions.strategy ?? "merge", removeUniversalSelector = true } = options ?? {};
-    const set = this.getClassCacheSet({
-      removeUniversalSelector
-    });
+  async getClassSet() {
+    const cacheStrategy = this.cacheOptions.strategy ?? "merge";
+    const set = await this.getClassCacheSet();
     if (cacheStrategy === "overwrite") {
       set.size > 0 && this.setCache(set);
     } else if (cacheStrategy === "merge") {
-      const cacheSet = this.getCache();
+      const cacheSet = await this.getCache();
       if (cacheSet) {
         for (const x of cacheSet) {
           set.add(x);
@@ -896,25 +906,27 @@ var TailwindcssPatcher = class {
   async extract(options) {
     const { output, tailwindcss } = options ?? {};
     if (output && tailwindcss) {
-      const { removeUniversalSelector, filename, loose } = output;
-      await processTailwindcss(tailwindcss);
-      const set = this.getClassSet({
-        removeUniversalSelector
-      });
+      const { filename, loose } = output;
+      if (this.majorVersion === 3) {
+        await processTailwindcss({
+          ...tailwindcss,
+          majorVersion: this.majorVersion
+        });
+      }
+      const set = await this.getClassSet();
       if (filename) {
-        await fs5.ensureDir(path7.dirname(filename));
         const classList = [...set];
-        await fs5.outputJSON(filename, classList, {
+        await fs4.outputJSON(filename, classList, {
           spaces: loose ? 2 : void 0
         });
         return filename;
       }
     }
   }
+  extractValidCandidates = extractValidCandidates;
 };
 
 export {
-  config_exports,
   logger_default,
   getCacheOptions,
   CacheManager,