@tailwindcss-mangle/core 2.3.0 → 4.0.0-alpha.0

package/dist/index.mjs

@@ -1,570 +0,0 @@
-import fs from 'node:fs';
-import { resolve, isAbsolute } from 'node:path';
-import process from 'node:process';
-import { ClassGenerator, defaultMangleClassFilter, splitCode, makeRegex } from '@tailwindcss-mangle/shared';
-export { ClassGenerator } from '@tailwindcss-mangle/shared';
-import { getConfig } from '@tailwindcss-mangle/config';
-import { sort } from 'fast-sort';
-import micromatch from 'micromatch';
-import postcss from 'postcss';
-import parser from 'postcss-selector-parser';
-import { Parser } from 'htmlparser2';
-import MagicString from 'magic-string';
-import { jsStringEscape } from '@ast-core/escape';
-import _babelTraverse from '@babel/traverse';
-import { parse } from '@babel/parser';
-import { parse as parse$1 } from '@vue/compiler-sfc';
-
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
-    return false;
-  }
-  if (Symbol.iterator in value) {
-    return false;
-  }
-  if (Symbol.toStringTag in value) {
-    return Object.prototype.toString.call(value) === "[object Module]";
-  }
-  return true;
-}
-
-function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isPlainObject(defaults)) {
-    return _defu(baseObject, {}, namespace, merger);
-  }
-  const object = Object.assign({}, defaults);
-  for (const key in baseObject) {
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = baseObject[key];
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (merger && merger(object, key, value, namespace)) {
-      continue;
-    }
-    if (Array.isArray(value) && Array.isArray(object[key])) {
-      object[key] = [...value, ...object[key]];
-    } else if (isPlainObject(value) && isPlainObject(object[key])) {
-      object[key] = _defu(
-        value,
-        object[key],
-        (namespace ? `${namespace}.` : "") + key.toString(),
-        merger
-      );
-    } else {
-      object[key] = value;
-    }
-  }
-  return object;
-}
-function createDefu(merger) {
-  return (...arguments_) => (
-    // eslint-disable-next-line unicorn/no-array-reduce
-    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
-  );
-}
-const defu = createDefu();
-
-const { isMatch } = micromatch;
-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 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 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 ?? 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 = 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, cwd: configCwd } = await getConfig(cwd);
-    this.mergeOptions(mangleOptions, config?.mangle);
-    if (_classList) {
-      this.loadClassSet(_classList);
-    } else {
-      let jsonPath = this.options.classListPath ?? resolve(process.cwd(), config?.patch?.output?.filename);
-      if (!isAbsolute(jsonPath)) {
-        jsonPath = resolve(configCwd ?? process.cwd(), jsonPath);
-      }
-      if (jsonPath && fs.existsSync(jsonPath)) {
-        const rawClassList = fs.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;
-  }
-  // ["clsx\\(([^)]*)\\)", "(?:'|\"|`)([^']*)(?:'|\"|`)"]
-}
-
-const postcssPlugin = "postcss-mangle-tailwindcss-plugin";
-function isVueScoped(s) {
-  if (s.parent) {
-    const index = s.parent.nodes.indexOf(s);
-    if (index > -1) {
-      const nextNode = s.parent.nodes[index + 1];
-      if (nextNode && nextNode.type === "attribute" && nextNode.attribute.includes("data-v-")) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-const transformSelectorPostcssPlugin = function(options) {
-  const { ignoreVueScoped, ctx } = defu(options, {
-    ignoreVueScoped: true
-  });
-  const replaceMap = ctx.replaceMap;
-  return {
-    postcssPlugin,
-    Once(root) {
-      root.walkRules((rule) => {
-        parser((selectors) => {
-          selectors.walkClasses((s) => {
-            if (s.value && replaceMap && replaceMap.has(s.value)) {
-              if (ignoreVueScoped && isVueScoped(s)) {
-                return;
-              }
-              const v = replaceMap.get(s.value);
-              if (v) {
-                if (ctx.isPreserveClass(s.value)) {
-                  rule.cloneBefore();
-                }
-                s.value = v;
-              }
-            }
-          });
-        }).transformSync(rule, {
-          lossless: false,
-          updateSelector: true
-        });
-      });
-    }
-  };
-};
-transformSelectorPostcssPlugin.postcss = true;
-
-function cssHandler(rawSource, options) {
-  const acceptedPlugins = [transformSelectorPostcssPlugin(options)];
-  const { file } = options;
-  return postcss(acceptedPlugins).process(rawSource, {
-    from: file,
-    to: file
-  });
-}
-
-function _interopDefaultCompat(e) {
-  return e && typeof e === "object" && "default" in e ? e.default : e;
-}
-const traverse = _interopDefaultCompat(_babelTraverse);
-
-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 { ctx, id, path, magicString, raw, offset = 0, escape = false, markedArray } = options;
-  const { replaceMap } = ctx;
-  const node = path.node;
-  let value = raw;
-  for (const [s, e] of markedArray) {
-    if (between(node.start, s, e) || between(node.end, s, e)) {
-      return;
-    }
-  }
-  const arr = sort(splitCode(value)).desc((x) => x.length);
-  for (const str of arr) {
-    if (replaceMap.has(str)) {
-      ctx.addToUsedBy(str, id);
-      const v = replaceMap.get(str);
-      if (v && typeof v === "string") {
-        value = value.replaceAll(str, v);
-      }
-    }
-  }
-  if (typeof node.start === "number" && typeof node.end === "number" && value) {
-    const start = node.start + offset;
-    const end = node.end - offset;
-    if (start < end) {
-      magicString.update(start, end, escape ? jsStringEscape(value) : value);
-    }
-  }
-}
-function preProcessJs(options) {
-  const { code, id, ctx } = options;
-  const { replaceMap } = ctx;
-  const magicString = typeof code === "string" ? new MagicString(code) : code;
-  let ast;
-  try {
-    const file = parse(magicString.original, {
-      sourceType: "unambiguous",
-      plugins: ["typescript", "jsx"]
-    });
-    if (file) {
-      ast = file;
-    } else {
-      return code.toString();
-    }
-  } catch {
-    return code.toString();
-  }
-  const markedArray = [];
-  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 = sort(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 = sort(splitCode(value)).desc((x) => x.length);
-                for (const str of arr) {
-                  if (replaceMap.has(str)) {
-                    ctx.addPreserveClass(str);
-                  }
-                }
-              }
-            }
-          });
-        }
-      }
-    },
-    StringLiteral: {
-      exit(p) {
-        handleValue$1({
-          ctx,
-          id,
-          magicString,
-          path: p,
-          raw: p.node.value,
-          offset: 1,
-          escape: true,
-          markedArray
-        });
-      }
-    },
-    TemplateElement: {
-      exit(p) {
-        handleValue$1({
-          ctx,
-          id,
-          magicString,
-          path: p,
-          raw: p.node.value.raw,
-          offset: 0,
-          escape: false,
-          markedArray
-        });
-      }
-    }
-  });
-  return magicString.toString();
-}
-function preProcessRawCode(options) {
-  const { code, ctx } = options;
-  const { replaceMap } = ctx;
-  const magicString = typeof code === "string" ? new MagicString(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 = parse(regExpMatch[0], {
-          sourceType: "unambiguous"
-        });
-        ast && traverse(ast, {
-          StringLiteral: {
-            enter(p) {
-              const arr2 = sort(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 = sort(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 && typeof value === "string") {
-        magicString.update(start, end, value);
-        markArr.push([start, end]);
-      }
-    }
-  }
-  return magicString.toString();
-}
-
-function handleValue(raw, node, options, ms, offset, escape) {
-  const { ctx, splitQuote = true } = options;
-  const { replaceMap, classGenerator: clsGen } = ctx;
-  const array = splitCode(raw, {
-    splitQuote
-  });
-  let rawString = raw;
-  let needUpdate = false;
-  for (const v of array) {
-    if (replaceMap.has(v)) {
-      let ignoreFlag = false;
-      if (Array.isArray(node.leadingComments)) {
-        ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes("tw-mangle") && x.value.includes("ignore")) > -1;
-      }
-      if (!ignoreFlag) {
-        rawString = rawString.replace(makeRegex(v), clsGen.generateClassName(v).name);
-        needUpdate = true;
-      }
-    }
-  }
-  if (needUpdate && typeof node.start === "number" && typeof node.end === "number") {
-    const start = node.start + offset;
-    const end = node.end - offset;
-    if (start < end && raw !== rawString) {
-      ms.update(start, end, escape ? jsStringEscape(rawString) : rawString);
-    }
-  }
-  return rawString;
-}
-function jsHandler(rawSource, options) {
-  const ms = typeof rawSource === "string" ? new MagicString(rawSource) : rawSource;
-  const ast = parse(ms.original, {
-    sourceType: "unambiguous",
-    plugins: ["typescript", "jsx"]
-  });
-  traverse(ast, {
-    StringLiteral: {
-      enter(p) {
-        const n = p.node;
-        handleValue(n.value, n, options, ms, 1, true);
-      }
-    },
-    TemplateElement: {
-      enter(p) {
-        const n = p.node;
-        handleValue(n.value.raw, n, options, ms, 0, false);
-      }
-    }
-    // CallExpression: {
-    //   enter(p: NodePath<CallExpression>) {
-    //     const calleePath = p.get('callee')
-    //     if (calleePath.isIdentifier() && calleePath.node.name === 'eval') {
-    //       p.traverse({
-    //         StringLiteral: {
-    //           enter(s) {
-    //             // ___CSS_LOADER_EXPORT___
-    //             const res = jsHandler(s.node.value, options)
-    //             if (res.code) {
-    //               s.node.value = res.code
-    //             }
-    //           },
-    //         },
-    //       })
-    //     }
-    //   },
-    // },
-  });
-  return {
-    code: ms.toString(),
-    get map() {
-      return ms.generateMap();
-    }
-  };
-}
-
-function htmlHandler(raw, options) {
-  const { ctx, isVue } = options;
-  const { replaceMap } = ctx;
-  const ms = typeof raw === "string" ? new MagicString(raw) : raw;
-  const parser = new Parser({
-    onattribute(name, value) {
-      if (name === "class") {
-        const arr = splitCode(value, {
-          splitQuote: false
-        });
-        let rawValue = value;
-        for (const v of arr) {
-          if (replaceMap.has(v)) {
-            rawValue = rawValue.replace(makeRegex(v), ctx.classGenerator.generateClassName(v).name);
-          }
-        }
-        ms.update(parser.startIndex + name.length + 2, parser.endIndex - 1, rawValue);
-      }
-      if (isVue) {
-        if (name === ":class") {
-          const { code } = jsHandler(value, {
-            ctx
-          });
-          ms.update(parser.startIndex + name.length + 2, parser.endIndex - 1, code);
-        }
-      }
-    }
-  });
-  parser.write(ms.original);
-  parser.end();
-  return ms.toString();
-}
-
-function vueHandler(raw, options) {
-  const { ctx } = options;
-  const ms = typeof raw === "string" ? new MagicString(raw) : raw;
-  const { descriptor } = parse$1(ms.original);
-  const { template, scriptSetup, script } = descriptor;
-  if (template) {
-    const code = htmlHandler(template.content, { ctx, isVue: true });
-    ms.update(template.loc.start.offset, template.loc.end.offset, code);
-  }
-  if (script) {
-    const x = jsHandler(script.content, { ctx });
-    ms.update(script.loc.start.offset, script.loc.end.offset, x.code);
-  }
-  if (scriptSetup) {
-    const x = jsHandler(scriptSetup.content, { ctx });
-    ms.update(scriptSetup.loc.start.offset, scriptSetup.loc.end.offset, x.code);
-  }
-  return ms.toString();
-}
-
-export { Context, cssHandler, handleValue, htmlHandler, jsHandler, preProcessJs, preProcessRawCode, vueHandler };