weapp-tailwindcss 4.7.0 → 4.7.2

package/dist/{chunk-7TKAJ3P6.mjs → chunk-JYCQWWYU.mjs}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-VSRDBMDB.mjs";
 import {
   createTailwindcssPatcherFromContext
-} from "./chunk-IY2OKZE6.mjs";
+} from "./chunk-3ARXMTWC.mjs";
 import {
   getDefaultOptions
-} from "./chunk-NRG7N2Q7.mjs";
+} from "./chunk-KZJLIZIK.mjs";
 import {
   defuOverrideArray,
   isMap
@@ -142,7 +142,6 @@ function toCustomAttributesEntities(customAttributes) {
 import { createStyleHandler } from "@weapp-tailwindcss/postcss";
 
 // src/js/babel.ts
-import { jsStringEscape as jsStringEscape2 } from "@ast-core/escape";
 import { LRUCache as LRUCache2 } from "lru-cache";
 import MagicString from "magic-string";
 
@@ -209,8 +208,86 @@ function createNameMatcher(list, { exact = false } = {}) {
   };
 }
 
-// src/js/handlers.ts
+// src/js/evalTransforms.ts
 import { jsStringEscape } from "@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() ? jsStringEscape(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
+import { jsStringEscape as jsStringEscape2 } from "@ast-core/escape";
 import { escapeStringRegexp as escapeStringRegexp2 } from "@weapp-core/regex";
 import { splitCode } from "@weapp-tailwindcss/shared/extractors";
 
@@ -355,7 +432,7 @@ function replaceHandleValue(path, options) {
   if (start >= end || transformed === original) {
     return void 0;
   }
-  const value = needEscaped ? jsStringEscape(transformed) : transformed;
+  const value = needEscaped ? jsStringEscape2(transformed) : transformed;
   return {
     start,
     end,
@@ -842,71 +919,7 @@ var NodePathWalker = class {
   }
 };
 
-// src/js/babel.ts
-var parseCache = new LRUCache2(
-  {
-    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 = parse(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() ? jsStringEscape2(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(
+    (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 (current.isParenthesizedExpression?.() || 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 (current.isTypeCastExpression?.()) {
+        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 (current.isCallExpression?.() || current.node.type === "CallExpression") {
+        const callee = current.get("callee");
+        current = callee;
+        continue;
+      }
+      break;
+    }
+    return current;
+  };
+  const evaluateTagPath = (tagPath) => {
+    if (tagPath.isCallExpression?.() || 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 LRUCache2(
+  {
+    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 = parse(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;
             }
           }
@@ -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 = createStyleHandler({
     cssPreflight,
-    customRuleCallback,
     cssPreflightRange,
     escapeMap,
     cssChildCombinatorReplaceValue,

package/dist/{chunk-NRG7N2Q7.mjs → chunk-KZJLIZIK.mjs}

@@ -67,7 +67,6 @@ function getDefaultOptions() {
       "border-color": "currentColor"
     },
     disabled: false,
-    customRuleCallback: noop,
     onLoad: noop,
     onStart: noop,
     onEnd: noop,

package/dist/{chunk-34T2BFTJ.mjs → chunk-KZUIVLPP.mjs}

@@ -53,7 +53,48 @@ function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
   return matchWithExtensions(candidate, hasOutput);
 }
 
+// src/bundlers/shared/run-tasks.ts
+async function runWithConcurrency(factories, limit = Math.min(4, Math.max(1, factories.length))) {
+  if (factories.length === 0) {
+    return [];
+  }
+  const results = Array.from({ length: factories.length });
+  const executing = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  const effectiveLimit = Math.max(1, limit);
+  const scheduleNext = () => {
+    if (cursor >= factories.length) {
+      return;
+    }
+    const currentIndex = cursor++;
+    const wrapped = Promise.resolve(factories[currentIndex]()).then((value) => {
+      results[currentIndex] = value;
+    }).finally(() => {
+      executing.delete(wrapped);
+    });
+    executing.add(wrapped);
+  };
+  while (cursor < factories.length && executing.size < effectiveLimit) {
+    scheduleNext();
+  }
+  while (cursor < factories.length) {
+    await Promise.race(executing);
+    scheduleNext();
+  }
+  await Promise.all(executing);
+  return results;
+}
+function pushConcurrentTaskFactories(queue, factories, limit) {
+  if (factories.length === 0) {
+    return;
+  }
+  queue.push(
+    runWithConcurrency(factories, limit).then(() => void 0)
+  );
+}
+
 export {
   toAbsoluteOutputPath,
-  resolveOutputSpecifier
+  resolveOutputSpecifier,
+  pushConcurrentTaskFactories
 };

package/dist/{chunk-C3CG4UUY.js → chunk-OPTIAB5G.js}

@@ -246,25 +246,29 @@ function normalizeTailwindcssPatcherOptions(options) {
 function createTailwindcssPatcher(options) {
   const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
   const cache = {};
+  const normalizedBasedir = basedir ? _path2.default.resolve(basedir) : void 0;
+  const cacheRoot = _nullishCoalesce(_nullishCoalesce(findNearestPackageRoot(normalizedBasedir), () => ( normalizedBasedir)), () => ( _process2.default.cwd()));
   if (cacheDir) {
     if (_path2.default.isAbsolute(cacheDir)) {
       cache.dir = cacheDir;
-    } else if (basedir) {
-      cache.dir = _path2.default.resolve(basedir, cacheDir);
+    } else if (normalizedBasedir) {
+      cache.dir = _path2.default.resolve(normalizedBasedir, cacheDir);
     } else {
       cache.dir = _path2.default.resolve(_process2.default.cwd(), cacheDir);
     }
+  } else {
+    cache.dir = _path2.default.join(cacheRoot, "node_modules", ".cache", "tailwindcss-patch");
   }
-  if (basedir) {
-    cache.cwd = basedir;
+  if (normalizedBasedir) {
+    cache.cwd = normalizedBasedir;
   }
-  const resolvePaths = createDefaultResolvePaths(_nullishCoalesce(_nullishCoalesce(cache.cwd, () => ( basedir)), () => ( _process2.default.cwd())));
+  const resolvePaths = createDefaultResolvePaths(_nullishCoalesce(_nullishCoalesce(cache.cwd, () => ( normalizedBasedir)), () => ( _process2.default.cwd())));
   const normalizedUserOptions = normalizeTailwindcssPatcherOptions(tailwindcssPatcherOptions);
   const extendLengthUnits = normalizeExtendLengthUnits(supportCustomLengthUnitsPatch);
   const baseTailwindOptions = _shared.defuOverrideArray.call(void 0, 
     _nullishCoalesce(tailwindcss, () => ( {})),
     {
-      cwd: basedir,
+      cwd: normalizedBasedir,
       resolve: {
         paths: resolvePaths
       }
@@ -290,7 +294,7 @@ function createTailwindcssPatcher(options) {
     }
   }
   const baseOptions = {
-    cwd: basedir,
+    cwd: normalizedBasedir,
     cache,
     tailwind: baseTailwindOptions,
     features: {
@@ -383,6 +387,12 @@ var ENV_BASEDIR_KEYS = [
   "PWD"
 ];
 var GENERIC_ENV_BASEDIR_KEYS = /* @__PURE__ */ new Set(["INIT_CWD", "PWD"]);
+function isLegacyTailwindcssPatcherOptions(options) {
+  return typeof options === "object" && options !== null && "patch" in options;
+}
+function isModernTailwindcssPatchOptions(options) {
+  return typeof options === "object" && options !== null && !("patch" in options);
+}
 function pickEnvBasedir() {
   for (const key of ENV_BASEDIR_KEYS) {
     const value = _process2.default.env[key];
@@ -541,7 +551,7 @@ function overrideTailwindcssPatcherOptionsForBase(options, baseDir, cssEntries)
   if (!options) {
     return options;
   }
-  if ("patch" in options) {
+  if (isLegacyTailwindcssPatcherOptions(options)) {
     const patchOptions = options.patch;
     if (!patchOptions) {
       return options;
@@ -566,6 +576,9 @@ function overrideTailwindcssPatcherOptionsForBase(options, baseDir, cssEntries)
       patch: nextPatch
     };
   }
+  if (!isModernTailwindcssPatchOptions(options)) {
+    return options;
+  }
   if (!options.tailwind) {
     return options;
   }

package/dist/{chunk-BTOCLUJ4.mjs → chunk-Q6PLZCM6.mjs}

@@ -3,11 +3,12 @@ import {
 } from "./chunk-RRHPTTCP.mjs";
 import {
   collectRuntimeClassSet,
-  createDebug
-} from "./chunk-YPBRGP6K.mjs";
+  createDebug,
+  createTailwindPatchPromise
+} from "./chunk-667CYXAH.mjs";
 import {
   getCompilerContext
-} from "./chunk-7TKAJ3P6.mjs";
+} from "./chunk-JYCQWWYU.mjs";
 
 // src/bundlers/gulp/index.ts
 import { Buffer } from "buffer";
@@ -21,7 +22,7 @@ function createPlugins(options = {}) {
   const opts = getCompilerContext(options);
   const { templateHandler, styleHandler, jsHandler, cache, twPatcher } = opts;
   let runtimeSet = /* @__PURE__ */ new Set();
-  const patchPromise = Promise.resolve(twPatcher.patch());
+  const patchPromise = createTailwindPatchPromise(twPatcher);
   const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"];
   let runtimeSetInitialized = false;
   async function refreshRuntimeSet(force = false) {
@@ -29,7 +30,7 @@ function createPlugins(options = {}) {
     if (!force && runtimeSetInitialized && runtimeSet.size > 0) {
       return runtimeSet;
     }
-    runtimeSet = await collectRuntimeClassSet(twPatcher);
+    runtimeSet = await collectRuntimeClassSet(twPatcher, { force });
     runtimeSetInitialized = true;
     return runtimeSet;
   }