@tailwindcss-mangle/core 2.1.0 → 2.2.1

package/dist/index.cjs

@@ -1,9 +1,14 @@
 'use strict';
 
+const fs = require('node:fs');
+const node_path = require('node:path');
+const shared = require('@tailwindcss-mangle/shared');
+const config = require('@tailwindcss-mangle/config');
+const fastSort = require('fast-sort');
+const micromatch = require('micromatch');
 const postcss = require('postcss');
 const parser = require('postcss-selector-parser');
 const parse5 = require('parse5');
-const shared = require('@tailwindcss-mangle/shared');
 const babel = require('@babel/core');
 const helperPluginUtils = require('@babel/helper-plugin-utils');
 const MagicString = require('magic-string');
@@ -11,6 +16,8 @@ const escape = require('@ast-core/escape');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const micromatch__default = /*#__PURE__*/_interopDefaultCompat(micromatch);
 const postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
 const parser__default = /*#__PURE__*/_interopDefaultCompat(parser);
 const babel__default = /*#__PURE__*/_interopDefaultCompat(babel);
@@ -58,7 +65,126 @@ function createDefu(merger) {
 }
 const defu = createDefu();
 
+const { isMatch } = micromatch__default;
+function escapeStringRegexp(str) {
+  if (typeof str !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return str.replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&").replaceAll("-", "\\x2d");
+}
+function createGlobMatcher(pattern, fallbackValue = false) {
+  if (pattern === void 0) {
+    return function() {
+      return fallbackValue;
+    };
+  }
+  return function(file) {
+    return isMatch(file, pattern);
+  };
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Context {
+  constructor() {
+    __publicField(this, "options");
+    __publicField(this, "includeMatcher");
+    __publicField(this, "excludeMatcher");
+    __publicField(this, "replaceMap");
+    __publicField(this, "classSet");
+    __publicField(this, "classGenerator");
+    __publicField(this, "preserveFunctionSet");
+    __publicField(this, "preserveClassNamesSet");
+    __publicField(this, "preserveFunctionRegexs");
+    this.options = {};
+    this.classSet = /* @__PURE__ */ new Set();
+    this.replaceMap = /* @__PURE__ */ new Map();
+    this.includeMatcher = () => true;
+    this.excludeMatcher = () => false;
+    this.classGenerator = new shared.ClassGenerator();
+    this.preserveFunctionSet = /* @__PURE__ */ new Set();
+    this.preserveClassNamesSet = /* @__PURE__ */ new Set();
+    this.preserveFunctionRegexs = [];
+  }
+  isPreserveClass(className) {
+    return this.preserveClassNamesSet.has(className);
+  }
+  addPreserveClass(className) {
+    return this.preserveClassNamesSet.add(className);
+  }
+  isPreserveFunction(calleeName) {
+    return this.preserveFunctionSet.has(calleeName);
+  }
+  mergeOptions(...opts) {
+    this.options = defu(this.options, ...opts);
+    this.includeMatcher = createGlobMatcher(this.options.include, true);
+    this.excludeMatcher = createGlobMatcher(this.options.exclude, false);
+    this.classGenerator = new shared.ClassGenerator(this.options.classGenerator);
+    this.preserveFunctionSet = new Set(this.options?.preserveFunction ?? []);
+    this.preserveFunctionRegexs = [...this.preserveFunctionSet.values()].map((x) => {
+      return new RegExp(escapeStringRegexp(x) + "\\(([^)]*)\\)", "g");
+    });
+  }
+  isInclude(file) {
+    return this.includeMatcher(file) && !this.excludeMatcher(file);
+  }
+  currentMangleClassFilter(className) {
+    return (this.options.mangleClassFilter ?? shared.defaultMangleClassFilter)(className);
+  }
+  getClassSet() {
+    return this.classSet;
+  }
+  getReplaceMap() {
+    return this.replaceMap;
+  }
+  addToUsedBy(key, file) {
+    const hit = this.classGenerator.newClassMap[key];
+    if (hit) {
+      hit.usedBy.add(file);
+    }
+  }
+  loadClassSet(classList) {
+    const list = fastSort.sort(classList).desc((c) => c.length);
+    for (const className of list) {
+      if (this.currentMangleClassFilter(className)) {
+        this.classSet.add(className);
+      }
+    }
+  }
+  async initConfig(opts = {}) {
+    const { cwd, classList: _classList, mangleOptions } = opts;
+    const { config: config$1, cwd: configCwd } = await config.getConfig(cwd);
+    this.mergeOptions(mangleOptions, config$1?.mangle);
+    if (_classList) {
+      this.loadClassSet(_classList);
+    } else {
+      let jsonPath = this.options.classListPath ?? node_path.resolve(process.cwd(), config$1?.patch?.output?.filename);
+      if (!node_path.isAbsolute(jsonPath)) {
+        jsonPath = node_path.resolve(configCwd ?? process.cwd(), jsonPath);
+      }
+      if (jsonPath && fs__default.existsSync(jsonPath)) {
+        const rawClassList = fs__default.readFileSync(jsonPath, "utf8");
+        const list = JSON.parse(rawClassList);
+        this.loadClassSet(list);
+      }
+    }
+    for (const cls of this.classSet) {
+      this.classGenerator.generateClassName(cls);
+    }
+    for (const x of Object.entries(this.classGenerator.newClassMap)) {
+      this.replaceMap.set(x[0], x[1].name);
+    }
+    return config$1;
+  }
+  // ["clsx\\(([^)]*)\\)", "(?:'|\"|`)([^']*)(?:'|\"|`)"]
+}
+
 const postcssPlugin = "postcss-mangle-tailwindcss-plugin";
+const clonedKey = "__tw_mangle_cloned__";
 function isVueScoped(s) {
   if (s.parent) {
     const index = s.parent.nodes.indexOf(s);
@@ -72,12 +198,15 @@ function isVueScoped(s) {
   return false;
 }
 const transformSelectorPostcssPlugin = function(options) {
-  const { ignoreVueScoped, replaceMap } = defu(options, {
+  const { ignoreVueScoped, replaceMap, ctx } = defu(options, {
     ignoreVueScoped: true
   });
   return {
     postcssPlugin,
     async Rule(rule) {
+      if (rule[clonedKey]) {
+        return;
+      }
       await parser__default((selectors) => {
         selectors.walkClasses((s) => {
           if (s.value && replaceMap && replaceMap.has(s.value)) {
@@ -86,6 +215,10 @@ const transformSelectorPostcssPlugin = function(options) {
             }
             const v = replaceMap.get(s.value);
             if (v) {
+              if (ctx.isPreserveClass(s.value)) {
+                const r = rule.cloneBefore();
+                r[clonedKey] = true;
+              }
               s.value = v;
             }
           }
@@ -202,7 +335,7 @@ function traverse(node, visitor, parent) {
 }
 
 function htmlHandler(rawSource, options) {
-  const { replaceMap, classGenerator } = options;
+  const { replaceMap, ctx } = options;
   const fragment = parse5.parse(rawSource);
   traverse(fragment, {
     element(node) {
@@ -213,7 +346,7 @@ function htmlHandler(rawSource, options) {
         });
         for (const v of array) {
           if (replaceMap.has(v)) {
-            attribute.value = attribute.value.replace(shared.makeRegex(v), classGenerator.generateClassName(v).name);
+            attribute.value = attribute.value.replace(shared.makeRegex(v), ctx.classGenerator.generateClassName(v).name);
           }
         }
       }
@@ -224,130 +357,26 @@ function htmlHandler(rawSource, options) {
 
 const isProd = () => process.env.NODE_ENV === "production";
 
-// >>> INTERFACES <<<
-// >>> HELPERS <<<
-var castComparer = function (comparer) { return function (a, b, order) { return comparer(a, b, order) * order; }; };
-var throwInvalidConfigErrorIfTrue = function (condition, context) {
-    if (condition)
-        throw Error("Invalid sort config: " + context);
-};
-var unpackObjectSorter = function (sortByObj) {
-    var _a = sortByObj || {}, asc = _a.asc, desc = _a.desc;
-    var order = asc ? 1 : -1;
-    var sortBy = (asc || desc);
-    // Validate object config
-    throwInvalidConfigErrorIfTrue(!sortBy, 'Expected `asc` or `desc` property');
-    throwInvalidConfigErrorIfTrue(asc && desc, 'Ambiguous object with `asc` and `desc` config properties');
-    var comparer = sortByObj.comparer && castComparer(sortByObj.comparer);
-    return { order: order, sortBy: sortBy, comparer: comparer };
-};
-// >>> SORTERS <<<
-var multiPropertySorterProvider = function (defaultComparer) {
-    return function multiPropertySorter(sortBy, sortByArr, depth, order, comparer, a, b) {
-        var valA;
-        var valB;
-        if (typeof sortBy === 'string') {
-            valA = a[sortBy];
-            valB = b[sortBy];
-        }
-        else if (typeof sortBy === 'function') {
-            valA = sortBy(a);
-            valB = sortBy(b);
-        }
-        else {
-            var objectSorterConfig = unpackObjectSorter(sortBy);
-            return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer, a, b);
-        }
-        var equality = comparer(valA, valB, order);
-        if ((equality === 0 || (valA == null && valB == null)) &&
-            sortByArr.length > depth) {
-            return multiPropertySorter(sortByArr[depth], sortByArr, depth + 1, order, comparer, a, b);
-        }
-        return equality;
-    };
-};
-function getSortStrategy(sortBy, comparer, order) {
-    // Flat array sorter
-    if (sortBy === undefined || sortBy === true) {
-        return function (a, b) { return comparer(a, b, order); };
-    }
-    // Sort list of objects by single object key
-    if (typeof sortBy === 'string') {
-        throwInvalidConfigErrorIfTrue(sortBy.includes('.'), 'String syntax not allowed for nested properties.');
-        return function (a, b) { return comparer(a[sortBy], b[sortBy], order); };
-    }
-    // Sort list of objects by single function sorter
-    if (typeof sortBy === 'function') {
-        return function (a, b) { return comparer(sortBy(a), sortBy(b), order); };
-    }
-    // Sort by multiple properties
-    if (Array.isArray(sortBy)) {
-        var multiPropSorter_1 = multiPropertySorterProvider(comparer);
-        return function (a, b) { return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a, b); };
-    }
-    // Unpack object config to get actual sorter strategy
-    var objectSorterConfig = unpackObjectSorter(sortBy);
-    return getSortStrategy(objectSorterConfig.sortBy, objectSorterConfig.comparer || comparer, objectSorterConfig.order);
-}
-var sortArray = function (order, ctx, sortBy, comparer) {
-    var _a;
-    if (!Array.isArray(ctx)) {
-        return ctx;
-    }
-    // Unwrap sortBy if array with only 1 value to get faster sort strategy
-    if (Array.isArray(sortBy) && sortBy.length < 2) {
-        _a = sortBy, sortBy = _a[0];
-    }
-    return ctx.sort(getSortStrategy(sortBy, comparer, order));
-};
-function createNewSortInstance(opts) {
-    var comparer = castComparer(opts.comparer);
-    return function (arrayToSort) {
-        var ctx = Array.isArray(arrayToSort) && !opts.inPlaceSorting
-            ? arrayToSort.slice()
-            : arrayToSort;
-        return {
-            asc: function (sortBy) {
-                return sortArray(1, ctx, sortBy, comparer);
-            },
-            desc: function (sortBy) {
-                return sortArray(-1, ctx, sortBy, comparer);
-            },
-            by: function (sortBy) {
-                return sortArray(1, ctx, sortBy, comparer);
-            },
-        };
-    };
-}
-var defaultComparer = function (a, b, order) {
-    if (a == null)
-        return order;
-    if (b == null)
-        return -order;
-    if (typeof a !== typeof b) {
-        return typeof a < typeof b ? -1 : 1;
-    }
-    if (a < b)
-        return -1;
-    if (a > b)
-        return 1;
-    return 0;
-};
-var sort = createNewSortInstance({
-    comparer: defaultComparer,
-});
-createNewSortInstance({
-    comparer: defaultComparer,
-    inPlaceSorting: true,
-});
+function between(x, min, max, included = false) {
+  if (typeof x !== "number") {
+    return false;
+  }
+  return included ? x >= min && x <= max : x > min && x < max;
+}
 
 function handleValue$1(options) {
-  const { addToUsedBy, id, magicString, node, raw, replaceMap, offset = 0, escape: escape$1 = false } = options;
+  const { ctx, id, path, magicString, raw, replaceMap, offset = 0, escape: escape$1 = false, markedArray } = options;
+  const node = path.node;
   let value = raw;
-  const arr = sort(shared.splitCode(value)).desc((x) => x.length);
+  for (const [s, e] of markedArray) {
+    if (between(node.start, s, e) || between(node.end, s, e)) {
+      return;
+    }
+  }
+  const arr = fastSort.sort(shared.splitCode(value)).desc((x) => x.length);
   for (const str of arr) {
     if (replaceMap.has(str)) {
-      addToUsedBy(str, id);
+      ctx.addToUsedBy(str, id);
       const v = replaceMap.get(str);
       if (v) {
         value = value.replaceAll(str, v);
@@ -362,76 +391,208 @@ function handleValue$1(options) {
     }
   }
 }
-const plugin = helperPluginUtils.declare((api, options) => {
+const JsPlugin = helperPluginUtils.declare((api, options) => {
   api.assertVersion(7);
-  const { magicString, replaceMap, id, addToUsedBy } = options;
+  const { magicString, replaceMap, id, ctx, markedArray } = options;
   return {
     visitor: {
       StringLiteral: {
-        enter(p) {
-          const node = p.node;
-          handleValue$1({
-            addToUsedBy,
+        exit(p) {
+          const opts = {
+            ctx,
             id,
             magicString,
-            node,
-            raw: node.value,
+            path: p,
+            raw: p.node.value,
             replaceMap,
             offset: 1,
-            escape: true
-          });
+            escape: true,
+            markedArray
+          };
+          handleValue$1(opts);
         }
       },
       TemplateElement: {
-        enter(p) {
-          const node = p.node;
-          handleValue$1({
-            addToUsedBy,
+        exit(p) {
+          const opts = {
+            ctx,
             id,
             magicString,
-            node,
-            raw: node.value.raw,
+            path: p,
+            raw: p.node.value.raw,
             replaceMap,
             offset: 0,
-            escape: false
-          });
+            escape: false,
+            markedArray
+          };
+          handleValue$1(opts);
         }
       }
     }
   };
 });
+function transformSync(ast, code, plugins, filename) {
+  babel__default.transformFromAstSync(ast, code, {
+    presets: loadPresets(),
+    plugins,
+    filename
+  });
+}
+function loadPresets() {
+  return [
+    [
+      require("@babel/preset-typescript"),
+      {
+        allExtensions: true,
+        isTSX: true
+      }
+    ]
+  ];
+}
 function preProcessJs(options) {
-  const { code, replaceMap, id, addToUsedBy } = options;
+  const { code, replaceMap, id, ctx } = options;
   const magicString = typeof code === "string" ? new MagicString__default(code) : code;
-  babel__default.transformSync(magicString.original, {
-    presets: [
-      // ['@babel/preset-react', {}],
-      [
-        require("@babel/preset-typescript"),
-        {
-          allExtensions: true,
-          isTSX: true
+  let ast;
+  try {
+    const file = babel__default.parseSync(magicString.original, {
+      sourceType: "unambiguous",
+      presets: loadPresets()
+    });
+    if (file) {
+      ast = file;
+    } else {
+      return code.toString();
+    }
+  } catch {
+    return code.toString();
+  }
+  const markedArray = [];
+  babel__default.traverse(ast, {
+    CallExpression: {
+      enter(p) {
+        const callee = p.get("callee");
+        if (callee.isIdentifier() && ctx.isPreserveFunction(callee.node.name)) {
+          if (p.node.start && p.node.end) {
+            markedArray.push([p.node.start, p.node.end]);
+          }
+          p.traverse({
+            StringLiteral: {
+              enter(path) {
+                const node = path.node;
+                const value = node.value;
+                const arr = fastSort.sort(shared.splitCode(value)).desc((x) => x.length);
+                for (const str of arr) {
+                  if (replaceMap.has(str)) {
+                    ctx.addPreserveClass(str);
+                  }
+                }
+              }
+            },
+            TemplateElement: {
+              enter(path) {
+                const node = path.node;
+                const value = node.value.raw;
+                const arr = fastSort.sort(shared.splitCode(value)).desc((x) => x.length);
+                for (const str of arr) {
+                  if (replaceMap.has(str)) {
+                    ctx.addPreserveClass(str);
+                  }
+                }
+              }
+            }
+          });
         }
-      ]
-    ],
-    plugins: [
+      }
+    }
+  });
+  transformSync(
+    ast,
+    magicString.original,
+    [
       [
-        plugin,
+        JsPlugin,
         {
           magicString,
           replaceMap,
           id,
-          addToUsedBy
+          ctx,
+          markedArray
         }
       ]
     ],
-    filename: id
-  });
+    id
+  );
+  return magicString.toString();
+}
+function preProcessRawCode(options) {
+  const { code, replaceMap, ctx } = options;
+  const magicString = typeof code === "string" ? new MagicString__default(code) : code;
+  const markArr = [];
+  for (const regex of ctx.preserveFunctionRegexs) {
+    const allArr = [];
+    let arr = null;
+    while ((arr = regex.exec(magicString.original)) !== null) {
+      allArr.push(arr);
+      markArr.push([arr.index, arr.index + arr[0].length]);
+    }
+    for (const regExpMatch of allArr) {
+      let ast;
+      try {
+        ast = babel__default.parseSync(regExpMatch[0], {
+          sourceType: "unambiguous"
+        });
+        ast && babel__default.traverse(ast, {
+          StringLiteral: {
+            enter(p) {
+              const arr2 = fastSort.sort(shared.splitCode(p.node.value)).desc((x) => x.length);
+              for (const v of arr2) {
+                if (replaceMap.has(v)) {
+                  ctx.addPreserveClass(v);
+                }
+              }
+            }
+          },
+          TemplateElement: {
+            enter(p) {
+              const arr2 = fastSort.sort(shared.splitCode(p.node.value.raw)).desc((x) => x.length);
+              for (const v of arr2) {
+                if (replaceMap.has(v)) {
+                  ctx.addPreserveClass(v);
+                }
+              }
+            }
+          }
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  for (const [key, value] of replaceMap) {
+    const regex = new RegExp(escapeStringRegexp(key), "g");
+    let arr = null;
+    while ((arr = regex.exec(magicString.original)) !== null) {
+      const start = arr.index;
+      const end = arr.index + arr[0].length;
+      let shouldUpdate = true;
+      for (const [ps, pe] of markArr) {
+        if (between(start, ps, pe) || between(end, ps, pe)) {
+          shouldUpdate = false;
+          break;
+        }
+      }
+      if (shouldUpdate) {
+        magicString.update(start, end, value);
+        markArr.push([start, end]);
+      }
+    }
+  }
   return magicString.toString();
 }
 
 function handleValue(raw, node, options) {
-  const { replaceMap, classGenerator: clsGen, splitQuote = true } = options;
+  const { replaceMap, ctx, splitQuote = true } = options;
+  const clsGen = ctx.classGenerator;
   const array = shared.splitCode(raw, {
     splitQuote
   });
@@ -499,8 +660,10 @@ function jsHandler(rawSource, options) {
 }
 
 exports.ClassGenerator = shared.ClassGenerator;
+exports.Context = Context;
 exports.cssHandler = cssHandler;
 exports.handleValue = handleValue;
 exports.htmlHandler = htmlHandler;
 exports.jsHandler = jsHandler;
 exports.preProcessJs = preProcessJs;
+exports.preProcessRawCode = preProcessRawCode;

package/dist/index.d.cts

@@ -0,0 +1,89 @@
+import * as _tailwindcss_mangle_config from '@tailwindcss-mangle/config';
+import { MangleUserConfig } from '@tailwindcss-mangle/config';
+import { ClassGenerator } from '@tailwindcss-mangle/shared';
+export { ClassGenerator } from '@tailwindcss-mangle/shared';
+import postcss from 'postcss';
+import { StringLiteral, TemplateElement } from '@babel/types';
+import { BabelFileResult } from '@babel/core';
+import MagicString from 'magic-string';
+
+interface InitConfigOptions {
+    cwd?: string;
+    classList?: string[];
+    mangleOptions?: MangleUserConfig;
+}
+declare class Context {
+    options: MangleUserConfig;
+    private includeMatcher;
+    private excludeMatcher;
+    private replaceMap;
+    classSet: Set<string>;
+    classGenerator: ClassGenerator;
+    preserveFunctionSet: Set<string>;
+    preserveClassNamesSet: Set<string>;
+    preserveFunctionRegexs: RegExp[];
+    constructor();
+    isPreserveClass(className: string): boolean;
+    addPreserveClass(className: string): Set<string>;
+    isPreserveFunction(calleeName: string): boolean;
+    private mergeOptions;
+    isInclude(file: string): boolean;
+    currentMangleClassFilter(className: string): boolean;
+    getClassSet(): Set<string>;
+    getReplaceMap(): Map<string, string>;
+    addToUsedBy(key: string, file: string): void;
+    loadClassSet(classList: string[]): void;
+    initConfig(opts?: InitConfigOptions): Promise<_tailwindcss_mangle_config.UserConfig | null>;
+}
+
+interface IClassGeneratorContextItem {
+    name: string;
+    usedBy: string[];
+}
+interface IClassGeneratorOptions {
+    reserveClassName?: (string | RegExp)[];
+    customGenerate?: (original: string, opts: IClassGeneratorOptions, context: Record<string, any>) => string | undefined;
+    log?: boolean;
+    exclude?: (string | RegExp)[];
+    include?: (string | RegExp)[];
+    ignoreClass?: (string | RegExp)[];
+    classPrefix?: string;
+}
+interface IHandlerOptions {
+    replaceMap: Map<string, string>;
+    ctx: Context;
+}
+interface IHtmlHandlerOptions extends IHandlerOptions {
+}
+interface IJsHandlerOptions extends IHandlerOptions {
+    splitQuote?: boolean;
+    minified?: boolean;
+}
+interface ICssHandlerOptions extends IHandlerOptions {
+    ignoreVueScoped?: boolean;
+    file?: string;
+}
+
+declare function cssHandler(rawSource: string, options: ICssHandlerOptions): postcss.LazyResult<postcss.Root>;
+
+declare function htmlHandler(rawSource: string, options: IHtmlHandlerOptions): string;
+
+interface IPreProcessJsOptions {
+    code: string | MagicString;
+    replaceMap: Map<string, string>;
+    id: string;
+    ctx: Context;
+}
+declare function preProcessJs(options: IPreProcessJsOptions): string;
+interface IPreProcessRawCodeOptions {
+    code: string | MagicString;
+    replaceMap: Map<string, string>;
+    id: string;
+    ctx: Context;
+}
+declare function preProcessRawCode(options: IPreProcessRawCodeOptions): string;
+
+declare function handleValue(raw: string, node: StringLiteral | TemplateElement, options: IJsHandlerOptions): string;
+declare function jsHandler(rawSource: string, options: IJsHandlerOptions): BabelFileResult;
+
+export { Context, type IClassGeneratorContextItem, type IClassGeneratorOptions, type ICssHandlerOptions, type IHandlerOptions, type IHtmlHandlerOptions, type IJsHandlerOptions, cssHandler, handleValue, htmlHandler, jsHandler, preProcessJs, preProcessRawCode };