weapp-tailwindcss 4.7.0 → 4.7.2

package/dist/{chunk-W3JU6K3T.js → chunk-FPDJ3BCM.js}

@@ -3,10 +3,10 @@
 var _chunkDWAEHRHNjs = require('./chunk-DWAEHRHN.js');
 
 
-var _chunkC3CG4UUYjs = require('./chunk-C3CG4UUY.js');
+var _chunkOPTIAB5Gjs = require('./chunk-OPTIAB5G.js');
 
 
-var _chunkLZ6L3UQOjs = require('./chunk-LZ6L3UQO.js');
+var _chunkWXBFAARRjs = require('./chunk-WXBFAARR.js');
 
 
 
@@ -142,7 +142,6 @@ function toCustomAttributesEntities(customAttributes) {
 var _postcss = require('@weapp-tailwindcss/postcss');
 
 // src/js/babel.ts
-var _escape = require('@ast-core/escape');
 
 var _magicstring = require('magic-string'); var _magicstring2 = _interopRequireDefault(_magicstring);
 
@@ -209,6 +208,84 @@ function createNameMatcher(list, { exact = false } = {}) {
   };
 }
 
+// src/js/evalTransforms.ts
+var _escape = require('@ast-core/escape');
+function isEvalPath(path) {
+  if (path.isCallExpression()) {
+    const calleePath = path.get("callee");
+    return calleePath.isIdentifier({ name: "eval" });
+  }
+  return false;
+}
+function createEvalReplacementToken(path, updated) {
+  const node = path.node;
+  let offset = 0;
+  let original;
+  if (path.isStringLiteral()) {
+    offset = 1;
+    original = path.node.value;
+  } else if (path.isTemplateElement()) {
+    original = path.node.value.raw;
+  } else {
+    original = "";
+  }
+  if (typeof node.start !== "number" || typeof node.end !== "number") {
+    return void 0;
+  }
+  const start = node.start + offset;
+  const end = node.end - offset;
+  if (start >= end) {
+    return void 0;
+  }
+  if (original === updated) {
+    return void 0;
+  }
+  const value = path.isStringLiteral() ? _escape.jsStringEscape.call(void 0, updated) : updated;
+  return {
+    start,
+    end,
+    value,
+    path
+  };
+}
+function handleEvalStringLiteral(path, options, updater, handler) {
+  const { code } = handler(path.node.value, {
+    ...options,
+    needEscaped: false,
+    generateMap: false
+  });
+  if (!code) {
+    return;
+  }
+  const token = createEvalReplacementToken(path, code);
+  if (token) {
+    updater.addToken(token);
+  }
+}
+function handleEvalTemplateElement(path, options, updater, handler) {
+  const { code } = handler(path.node.value.raw, {
+    ...options,
+    generateMap: false
+  });
+  if (!code) {
+    return;
+  }
+  const token = createEvalReplacementToken(path, code);
+  if (token) {
+    updater.addToken(token);
+  }
+}
+function walkEvalExpression(path, options, updater, handler) {
+  path.traverse({
+    StringLiteral(innerPath) {
+      handleEvalStringLiteral(innerPath, options, updater, handler);
+    },
+    TemplateElement(innerPath) {
+      handleEvalTemplateElement(innerPath, options, updater, handler);
+    }
+  });
+}
+
 // src/js/handlers.ts
 
 
@@ -842,71 +919,7 @@ var NodePathWalker = class {
   }
 };
 
-// src/js/babel.ts
-var parseCache = new (0, _lrucache.LRUCache)(
-  {
-    max: 512
-  }
-);
-function genCacheKey(source, options) {
-  return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
-}
-function babelParse(code, { cache, ...options } = {}) {
-  const cacheKey = genCacheKey(code, options);
-  let result;
-  if (cache) {
-    result = parseCache.get(cacheKey);
-  }
-  if (!result) {
-    result = _parser.parse.call(void 0, code, options);
-    if (cache) {
-      parseCache.set(cacheKey, result);
-    }
-  }
-  return result;
-}
-function isEvalPath(p) {
-  if (p.isCallExpression()) {
-    const calleePath = p.get("callee");
-    return calleePath.isIdentifier(
-      {
-        name: "eval"
-      }
-    );
-  }
-  return false;
-}
-function createEvalReplacementToken(path, updated) {
-  const node = path.node;
-  let offset = 0;
-  let original;
-  if (path.isStringLiteral()) {
-    offset = 1;
-    original = path.node.value;
-  } else if (path.isTemplateElement()) {
-    original = path.node.value.raw;
-  } else {
-    original = "";
-  }
-  if (typeof node.start !== "number" || typeof node.end !== "number") {
-    return void 0;
-  }
-  const start = node.start + offset;
-  const end = node.end - offset;
-  if (start >= end) {
-    return void 0;
-  }
-  if (original === updated) {
-    return void 0;
-  }
-  const value = path.isStringLiteral() ? _escape.jsStringEscape.call(void 0, updated) : updated;
-  return {
-    start,
-    end,
-    value,
-    path
-  };
-}
+// src/js/sourceAnalysis.ts
 function createModuleSpecifierReplacementToken(path, replacement) {
   const node = path.node;
   if (node.value === replacement) {
@@ -964,42 +977,179 @@ function collectModuleSpecifierReplacementTokens(analysis, replacements) {
   }
   return tokens;
 }
-function handleEvalStringLiteral(path, options, updater, handler) {
-  const { code } = handler(path.node.value, {
-    ...options,
-    needEscaped: false,
-    generateMap: false
-  });
-  if (!code) {
-    return;
-  }
-  const token = createEvalReplacementToken(path, code);
-  if (token) {
-    updater.addToken(token);
-  }
+
+// src/js/taggedTemplateIgnore.ts
+function createTaggedTemplateIgnore({ matcher, names }) {
+  const bindingIgnoreCache = /* @__PURE__ */ new Map();
+  const taggedTemplateIgnoreCache = /* @__PURE__ */ new WeakMap();
+  const canonicalIgnoreNames = new Set(
+    (_nullishCoalesce(names, () => ( []))).filter((item) => typeof item === "string")
+  );
+  const propertyMatches = (propertyPath) => {
+    if (!propertyPath) {
+      return false;
+    }
+    if (propertyPath.isIdentifier()) {
+      const { name } = propertyPath.node;
+      return canonicalIgnoreNames.has(name) || matcher(name);
+    }
+    if (propertyPath.isStringLiteral()) {
+      const { value } = propertyPath.node;
+      return canonicalIgnoreNames.has(value) || matcher(value);
+    }
+    return false;
+  };
+  const resolvesMemberExpressionToIgnore = (path, seen) => {
+    const propertyPath = path.get("property");
+    if (propertyMatches(propertyPath)) {
+      return true;
+    }
+    const objectPath = path.get("object");
+    if (objectPath.isIdentifier()) {
+      const binding = objectPath.scope.getBinding(objectPath.node.name);
+      if (binding) {
+        return resolvesToWeappTwIgnore(binding, seen);
+      }
+    }
+    return false;
+  };
+  const resolvesToWeappTwIgnore = (binding, seen) => {
+    const cached = bindingIgnoreCache.get(binding);
+    if (cached !== void 0) {
+      return cached;
+    }
+    if (seen.has(binding)) {
+      return false;
+    }
+    seen.add(binding);
+    let result = false;
+    const bindingPath = binding.path;
+    if (bindingPath.isImportSpecifier()) {
+      const imported = bindingPath.node.imported;
+      if (imported.type === "Identifier" && (canonicalIgnoreNames.has(imported.name) || matcher(imported.name))) {
+        result = true;
+      } else if (imported.type === "StringLiteral" && (canonicalIgnoreNames.has(imported.value) || matcher(imported.value))) {
+        result = true;
+      }
+    } else if (bindingPath.isVariableDeclarator()) {
+      const init = bindingPath.get("init");
+      if (init && init.node) {
+        if (init.isIdentifier()) {
+          const target = binding.scope.getBinding(init.node.name);
+          if (target) {
+            result = resolvesToWeappTwIgnore(target, seen);
+          }
+        } else if (init.isMemberExpression()) {
+          result = resolvesMemberExpressionToIgnore(init, seen);
+        }
+      }
+    }
+    bindingIgnoreCache.set(binding, result);
+    seen.delete(binding);
+    return result;
+  };
+  const getEffectiveTagPath = (tagPath) => {
+    let current = tagPath;
+    while (true) {
+      if (_optionalChain([current, 'access', _18 => _18.isParenthesizedExpression, 'optionalCall', _19 => _19()]) || current.node.type === "ParenthesizedExpression") {
+        current = current.get("expression");
+        continue;
+      }
+      if (current.isTSAsExpression() || current.isTSTypeAssertion()) {
+        current = current.get("expression");
+        continue;
+      }
+      if (current.isTSNonNullExpression()) {
+        current = current.get("expression");
+        continue;
+      }
+      if (_optionalChain([current, 'access', _20 => _20.isTypeCastExpression, 'optionalCall', _21 => _21()])) {
+        current = current.get("expression");
+        continue;
+      }
+      if (current.isSequenceExpression()) {
+        const expressions = current.get("expressions");
+        const last = expressions[expressions.length - 1];
+        if (last) {
+          current = last;
+          continue;
+        }
+      }
+      if (_optionalChain([current, 'access', _22 => _22.isCallExpression, 'optionalCall', _23 => _23()]) || current.node.type === "CallExpression") {
+        const callee = current.get("callee");
+        current = callee;
+        continue;
+      }
+      break;
+    }
+    return current;
+  };
+  const evaluateTagPath = (tagPath) => {
+    if (_optionalChain([tagPath, 'access', _24 => _24.isCallExpression, 'optionalCall', _25 => _25()]) || tagPath.node.type === "CallExpression") {
+      const calleePath = tagPath.get("callee");
+      return evaluateTagPath(calleePath);
+    }
+    if (tagPath.isIdentifier()) {
+      if (matcher(tagPath.node.name)) {
+        return true;
+      }
+      const binding = tagPath.scope.getBinding(tagPath.node.name);
+      if (binding) {
+        return resolvesToWeappTwIgnore(binding, /* @__PURE__ */ new Set());
+      }
+      return false;
+    }
+    if (tagPath.isMemberExpression()) {
+      return resolvesMemberExpressionToIgnore(tagPath, /* @__PURE__ */ new Set());
+    }
+    return false;
+  };
+  const computeIgnore = (tagPath) => {
+    const cached = taggedTemplateIgnoreCache.get(tagPath.node);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const effectiveTagPath = getEffectiveTagPath(tagPath);
+    const effectiveCached = taggedTemplateIgnoreCache.get(effectiveTagPath.node);
+    if (effectiveCached !== void 0) {
+      taggedTemplateIgnoreCache.set(tagPath.node, effectiveCached);
+      return effectiveCached;
+    }
+    const result = evaluateTagPath(effectiveTagPath);
+    taggedTemplateIgnoreCache.set(effectiveTagPath.node, result);
+    taggedTemplateIgnoreCache.set(tagPath.node, result);
+    return result;
+  };
+  return {
+    shouldIgnore(tagPath) {
+      return computeIgnore(tagPath);
+    },
+    getEffectiveTagPath
+  };
 }
-function handleEvalTemplateElement(path, options, updater, handler) {
-  const { code } = handler(path.node.value.raw, {
-    ...options,
-    generateMap: false
-  });
-  if (!code) {
-    return;
-  }
-  const token = createEvalReplacementToken(path, code);
-  if (token) {
-    updater.addToken(token);
+
+// src/js/babel.ts
+var parseCache = new (0, _lrucache.LRUCache)(
+  {
+    max: 512
   }
+);
+function genCacheKey(source, options) {
+  return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
 }
-function walkEvalExpression(path, options, updater, handler) {
-  path.traverse({
-    StringLiteral(innerPath) {
-      handleEvalStringLiteral(innerPath, options, updater, handler);
-    },
-    TemplateElement(innerPath) {
-      handleEvalTemplateElement(innerPath, options, updater, handler);
+function babelParse(code, { cache, ...options } = {}) {
+  const cacheKey = genCacheKey(code, options);
+  let result;
+  if (cache) {
+    result = parseCache.get(cacheKey);
+  }
+  if (!result) {
+    result = _parser.parse.call(void 0, code, options);
+    if (cache) {
+      parseCache.set(cacheKey, result);
     }
-  });
+  }
+  return result;
 }
 function analyzeSource(ast, options, handler) {
   const jsTokenUpdater = new JsTokenUpdater();
@@ -1015,6 +1165,10 @@ function analyzeSource(ast, options, handler) {
     }
   );
   const isIgnoredTaggedTemplate = createNameMatcher(options.ignoreTaggedTemplateExpressionIdentifiers, { exact: true });
+  const taggedTemplateIgnore = createTaggedTemplateIgnore({
+    matcher: isIgnoredTaggedTemplate,
+    names: options.ignoreTaggedTemplateExpressionIdentifiers
+  });
   const targetPaths = [];
   const importDeclarations = /* @__PURE__ */ new Set();
   const exportDeclarations = /* @__PURE__ */ new Set();
@@ -1039,7 +1193,7 @@ function analyzeSource(ast, options, handler) {
           }
           if (ppp.isTaggedTemplateExpression()) {
             const tagPath = ppp.get("tag");
-            if (tagPath.isIdentifier() && isIgnoredTaggedTemplate(tagPath.node.name)) {
+            if (taggedTemplateIgnore.shouldIgnore(tagPath)) {
               return;
             }
           }
@@ -1058,7 +1212,7 @@ function analyzeSource(ast, options, handler) {
           const args = p.get("arguments");
           if (Array.isArray(args) && args.length > 0) {
             const first = args[0];
-            if (_optionalChain([first, 'optionalAccess', _18 => _18.isStringLiteral, 'call', _19 => _19()])) {
+            if (_optionalChain([first, 'optionalAccess', _26 => _26.isStringLiteral, 'call', _27 => _27()])) {
               requireCallPaths.push(first);
             }
           }
@@ -1368,7 +1522,7 @@ function generateCode(match, options = {}) {
           if (t.isMemberExpression(path.parent)) {
             return;
           }
-          if (t.isBinaryExpression(path.parent) && (t.isConditionalExpression(_optionalChain([path, 'access', _20 => _20.parentPath, 'optionalAccess', _21 => _21.parent])) || t.isLogicalExpression(_optionalChain([path, 'access', _22 => _22.parentPath, 'optionalAccess', _23 => _23.parent])))) {
+          if (t.isBinaryExpression(path.parent) && (t.isConditionalExpression(_optionalChain([path, 'access', _28 => _28.parentPath, 'optionalAccess', _29 => _29.parent])) || t.isLogicalExpression(_optionalChain([path, 'access', _30 => _30.parentPath, 'optionalAccess', _31 => _31.parent])))) {
             return;
           }
           jsTokenUpdater.addToken(
@@ -1618,7 +1772,6 @@ function resolveRuntimePackageReplacements(option) {
 function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions) {
   const {
     cssPreflight,
-    customRuleCallback,
     cssPreflightRange,
     escapeMap,
     cssChildCombinatorReplaceValue,
@@ -1643,7 +1796,6 @@ function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions
   const moduleSpecifierReplacements = resolveRuntimePackageReplacements(replaceRuntimePackages);
   const styleHandler = _postcss.createStyleHandler.call(void 0, {
     cssPreflight,
-    customRuleCallback,
     cssPreflightRange,
     escapeMap,
     cssChildCombinatorReplaceValue,
@@ -1748,13 +1900,13 @@ function ensureDefaultsIncluded(value) {
 function getCompilerContext(opts) {
   const ctx = _chunkUW3WHSZ5js.defuOverrideArray.call(void 0, 
     opts,
-    _chunkLZ6L3UQOjs.getDefaultOptions.call(void 0, ),
+    _chunkWXBFAARRjs.getDefaultOptions.call(void 0, ),
     {}
   );
   ctx.escapeMap = ctx.customReplaceDictionary;
   applyLoggerLevel(ctx.logLevel);
-  const twPatcher = _chunkC3CG4UUYjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
-  if (_optionalChain([twPatcher, 'access', _24 => _24.packageInfo, 'optionalAccess', _25 => _25.version])) {
+  const twPatcher = _chunkOPTIAB5Gjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
+  if (_optionalChain([twPatcher, 'access', _32 => _32.packageInfo, 'optionalAccess', _33 => _33.version])) {
     _logger.logger.success(`\u5F53\u524D\u4F7F\u7528 ${_logger.pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${_logger.pc.underline(_logger.pc.bold(_logger.pc.green(twPatcher.packageInfo.version)))}`);
   } else {
     _logger.logger.warn(`${_logger.pc.cyanBright("Tailwind CSS")} \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7\u7248\u672C\u68C0\u6D4B\u4E0E\u8865\u4E01\u5E94\u7528\u3002`);