@weapp-tailwindcss/postcss 2.0.6 → 2.0.8

package/dist/index.mjs

@@ -1,8 +1,7 @@
 import "./chunk-WAXGOBY2.mjs";
 
 // src/handler.ts
-import { defuOverrideArray as defuOverrideArray3 } from "@weapp-tailwindcss/shared";
-import postcss from "postcss";
+import { defuOverrideArray as defuOverrideArray4 } from "@weapp-tailwindcss/shared";
 
 // src/defaults.ts
 function getDefaultOptions(options) {
@@ -35,6 +34,102 @@ function getDefaultOptions(options) {
   };
 }
 
+// src/options-resolver.ts
+import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+
+// src/fingerprint.ts
+function fingerprintOptions(value, state = { map: /* @__PURE__ */ new WeakMap(), counter: 0 }) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "function") {
+    return `fn:${value.name || "anonymous"}`;
+  }
+  if (typeof value === "symbol") {
+    return `sym:${String(value)}`;
+  }
+  if (typeof value !== "object") {
+    return `${typeof value}:${String(value)}`;
+  }
+  const objectValue = value;
+  const cached = state.map.get(objectValue);
+  if (cached) {
+    return cached;
+  }
+  const marker = `ref:${state.counter++}`;
+  state.map.set(objectValue, marker);
+  if (Array.isArray(objectValue)) {
+    const parts2 = objectValue.map((entry) => fingerprintOptions(entry, state));
+    return `[${parts2.join(",")}]`;
+  }
+  const keys = Object.keys(objectValue).sort();
+  const parts = keys.map((key) => `${key}:${fingerprintOptions(objectValue[key], state)}`);
+  return `{${parts.join(",")}}@${marker}`;
+}
+
+// src/options-resolver.ts
+var BASE_CACHE_KEY = "base";
+function hasOverrides(options) {
+  return Boolean(options && Object.keys(options).length > 0);
+}
+function createOptionsResolver(baseOptions) {
+  const cacheByKey = /* @__PURE__ */ new Map();
+  const cacheByRef = /* @__PURE__ */ new WeakMap();
+  const fingerprintByRef = /* @__PURE__ */ new WeakMap();
+  cacheByKey.set(BASE_CACHE_KEY, baseOptions);
+  const resolve = (overrides) => {
+    if (!hasOverrides(overrides)) {
+      return baseOptions;
+    }
+    const refCached = cacheByRef.get(overrides);
+    if (refCached) {
+      return refCached;
+    }
+    let key = fingerprintByRef.get(overrides);
+    if (!key) {
+      key = fingerprintOptions(overrides);
+      fingerprintByRef.set(overrides, key);
+    }
+    const cached = cacheByKey.get(key);
+    if (cached) {
+      cacheByRef.set(overrides, cached);
+      return cached;
+    }
+    const merged = defuOverrideArray(
+      { ...overrides },
+      baseOptions
+    );
+    cacheByKey.set(key, merged);
+    cacheByRef.set(overrides, merged);
+    return merged;
+  };
+  return {
+    resolve
+  };
+}
+
+// src/preflight.ts
+function createInjectPreflight(options) {
+  const result = [];
+  if (options && typeof options === "object") {
+    const entries = Object.entries(options);
+    for (const [prop, value] of entries) {
+      if (value !== false) {
+        result.push({
+          prop,
+          value: value.toString()
+        });
+      }
+    }
+  }
+  return () => {
+    return result;
+  };
+}
+
+// src/processor-cache.ts
+import postcss from "postcss";
+
 // src/pipeline.ts
 import postcssPresetEnv from "postcss-preset-env";
 
@@ -154,7 +249,7 @@ function createContext() {
 // src/plugins/getCalcPlugin.ts
 import postcssCalc from "@weapp-tailwindcss/postcss-calc";
 
-// ../../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/object/omit.mjs
+// ../../node_modules/.pnpm/es-toolkit@1.43.0/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -219,7 +314,7 @@ function getCustomPropertyCleaner(options) {
 }
 
 // src/plugins/getPxTransformPlugin.ts
-import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
 import postcssPxtransform from "postcss-pxtransform";
 var defaultPxTransformOptions = {
   platform: "weapp",
@@ -243,7 +338,7 @@ function getPxTransformPlugin(options) {
   }
   const userOptions = typeof options.px2rpx === "object" ? options.px2rpx : {};
   return postcssPxtransform(
-    defuOverrideArray(
+    defuOverrideArray2(
       userOptions,
       defaultPxTransformOptions
     )
@@ -251,7 +346,7 @@ function getPxTransformPlugin(options) {
 }
 
 // src/plugins/getRemTransformPlugin.ts
-import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
+import { defuOverrideArray as defuOverrideArray3 } from "@weapp-tailwindcss/shared";
 import postcssRem2rpx from "postcss-rem-to-responsive-pixel";
 var defaultRemOptions = {
   rootValue: 32,
@@ -266,7 +361,7 @@ function getRemTransformPlugin(options) {
     return null;
   }
   const userOptions = typeof options.rem2rpx === "object" ? options.rem2rpx : defaultRemOptions;
-  const merged = defuOverrideArray2(
+  const merged = defuOverrideArray3(
     userOptions,
     defaultStage
   );
@@ -276,8 +371,36 @@ function getRemTransformPlugin(options) {
 // src/plugins/post.ts
 import { defu } from "@weapp-tailwindcss/shared";
 
-// src/compat/tailwindcss-v4.ts
-import { Declaration } from "postcss";
+// src/compat/tailwindcss-rpx.ts
+var LENGTH_VALUE_REGEXP = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?rpx$/i;
+function normalizeTailwindcssRpxDeclaration(decl, options) {
+  const majorVersion = options?.majorVersion;
+  const normalizedValue = decl.value.trim();
+  if (LENGTH_VALUE_REGEXP.test(normalizedValue) && (majorVersion === void 0 || majorVersion === 2 || majorVersion === 3 || majorVersion === 4)) {
+    const lowerProp = decl.prop.toLowerCase();
+    if (lowerProp === "color") {
+      decl.prop = "font-size";
+      return true;
+    }
+    if (lowerProp === "background-color") {
+      decl.prop = "background-size";
+      return true;
+    }
+    if (lowerProp === "outline-color") {
+      decl.prop = "outline-width";
+      return true;
+    }
+    if (lowerProp.startsWith("border") && lowerProp.endsWith("color")) {
+      decl.prop = `${decl.prop.slice(0, -"color".length)}width`;
+      return true;
+    }
+    if (lowerProp === "--tw-ring-color") {
+      decl.prop = "--tw-ring-offset-width";
+      return true;
+    }
+  }
+  return false;
+}
 
 // src/cssVarsV4.ts
 function property(ident, initialValue, _syntax) {
@@ -417,6 +540,15 @@ for (const edge of ["top", "right", "bottom", "left"]) {
 }
 var cssVarsV4_default = nodes;
 
+// src/utils/css-vars.ts
+import { Declaration } from "postcss";
+function createCssVarNodes(definitions) {
+  return definitions.map((def) => new Declaration({
+    prop: def.prop,
+    value: def.value
+  }));
+}
+
 // src/compat/tailwindcss-v4.ts
 var OKLAB_SUFFIX = "in oklab";
 var INFINITY_CALC_REGEXP = /calc\(\s*infinity\s*\*\s*(?:\d+(?:\.\d*)?|\.\d+)r?px/;
@@ -428,12 +560,7 @@ function isTailwindcssV4(options) {
 function testIfRootHostForV4(node) {
   return node.type === "rule" && node.selector.includes(":root") && node.selector.includes(":host");
 }
-var cssVarsV4Nodes = cssVarsV4_default.map((x) => {
-  return new Declaration({
-    prop: x.prop,
-    value: x.value
-  });
-});
+var cssVarsV4Nodes = createCssVarNodes(cssVarsV4_default);
 function isTailwindcssV4ModernCheck(atRule) {
   return atRule.name === "supports" && [
     /-webkit-hyphens\s*:\s*none/,
@@ -583,6 +710,7 @@ function getCombinatorSelectorAst(options) {
 // src/selectorParser/fallback.ts
 var fallbackRemoveCache = /* @__PURE__ */ new WeakMap();
 var fallbackDefaultKey = {};
+var FALLBACK_TRANSFORM_OPTIONS = normalizeTransformOptions();
 function getFallbackRemove(_rule, options) {
   const cacheKey = options ?? fallbackDefaultKey;
   let entry = fallbackRemoveCache.get(cacheKey);
@@ -647,24 +775,25 @@ function getFallbackRemove(_rule, options) {
     const transform = (targetRule) => {
       currentRule = targetRule;
       try {
-        rawTransformSync(targetRule, normalizeTransformOptions());
+        rawTransformSync(targetRule, FALLBACK_TRANSFORM_OPTIONS);
       } finally {
         currentRule = void 0;
       }
     };
     parser.transformSync = ((input, opts) => {
+      const transformOptions = opts ? normalizeTransformOptions(opts) : FALLBACK_TRANSFORM_OPTIONS;
       if (input && typeof input === "object" && "type" in input) {
         const maybeRule = input;
         if (maybeRule.type === "rule") {
           currentRule = input;
           try {
-            return rawTransformSync(input, normalizeTransformOptions(opts));
+            return rawTransformSync(input, transformOptions);
           } finally {
             currentRule = void 0;
           }
         }
       }
-      return rawTransformSync(input, opts);
+      return rawTransformSync(input, transformOptions);
     });
     entry = {
       parser,
@@ -698,6 +827,47 @@ function composeIsPseudo(strs) {
   return strs.join("");
 }
 
+// src/utils/decl-order.ts
+function reorderLiteralFirst(rule, declarations, isVariable) {
+  if (declarations.length <= 1) {
+    return;
+  }
+  const literals = [];
+  const variables = [];
+  for (const decl of declarations) {
+    if (isVariable(decl)) {
+      variables.push(decl);
+    } else {
+      literals.push(decl);
+    }
+  }
+  if (literals.length === 0 || variables.length === 0) {
+    return;
+  }
+  const desired = [...literals, ...variables];
+  let alreadyOrdered = true;
+  for (let index = 0; index < desired.length; index++) {
+    if (desired[index] !== declarations[index]) {
+      alreadyOrdered = false;
+      break;
+    }
+  }
+  if (alreadyOrdered) {
+    return;
+  }
+  const anchor = declarations[declarations.length - 1]?.next() ?? void 0;
+  for (const decl of declarations) {
+    decl.remove();
+  }
+  for (const decl of desired) {
+    if (anchor) {
+      rule.insertBefore(anchor, decl);
+    } else {
+      rule.append(decl);
+    }
+  }
+}
+
 // src/selectorParser/rule-transformer.ts
 var ruleTransformCache = /* @__PURE__ */ new WeakMap();
 var MIRROR_PROP_PAIRS = [
@@ -725,6 +895,7 @@ var LEGACY_WEBKIT_SPACING_PROPS = /* @__PURE__ */ new Set([
   "-webkit-margin-after"
 ]);
 var VAR_REFERENCE_PATTERN = /var\(/i;
+var SELECTOR_TRANSFORM_OPTIONS = normalizeTransformOptions();
 function dedupeSpacingProps(rule) {
   const grouped = /* @__PURE__ */ new Map();
   for (const node of rule.nodes) {
@@ -762,27 +933,11 @@ function dedupeSpacingProps(rule) {
     if (unique.length <= 1) {
       continue;
     }
-    const literals = unique.filter((decl) => !VAR_REFERENCE_PATTERN.test(decl.value));
-    const variables = unique.filter((decl) => VAR_REFERENCE_PATTERN.test(decl.value));
-    if (variables.length === 0 || literals.length === 0) {
-      continue;
-    }
-    const ordered = [...literals, ...variables];
-    const alreadyOrdered = ordered.every((decl, index) => decl === unique[index]);
-    if (alreadyOrdered) {
-      continue;
-    }
-    const anchor = unique[unique.length - 1]?.next() ?? void 0;
-    for (const decl of unique) {
-      decl.remove();
-    }
-    for (const decl of ordered) {
-      if (anchor) {
-        rule.insertBefore(anchor, decl);
-      } else {
-        rule.append(decl);
-      }
-    }
+    reorderLiteralFirst(
+      rule,
+      unique,
+      (decl) => VAR_REFERENCE_PATTERN.test(decl.value)
+    );
   }
 }
 function isNotLastChildPseudo(node) {
@@ -992,7 +1147,7 @@ function createRuleTransformer(options) {
       rule
     };
     try {
-      parser.transformSync(rule, normalizeTransformOptions());
+      parser.transformSync(rule, SELECTOR_TRANSFORM_OPTIONS);
     } finally {
       context = void 0;
     }
@@ -1158,33 +1313,11 @@ function dedupeDeclarations(rule) {
     if (declarations.length <= 1) {
       continue;
     }
-    const literals = declarations.filter((decl) => !hasVariableReference(decl.value));
-    const variables = declarations.filter((decl) => hasVariableReference(decl.value));
-    if (literals.length === 0 || variables.length === 0) {
-      continue;
-    }
-    const ordered = [...literals, ...variables];
-    let needReorder = false;
-    for (let index = 0; index < ordered.length; index++) {
-      if (ordered[index] !== declarations[index]) {
-        needReorder = true;
-        break;
-      }
-    }
-    if (!needReorder) {
-      continue;
-    }
-    const anchor = declarations[declarations.length - 1]?.next() ?? void 0;
-    for (const decl of declarations) {
-      decl.remove();
-    }
-    for (const decl of ordered) {
-      if (anchor) {
-        rule.insertBefore(anchor, decl);
-      } else {
-        rule.append(decl);
-      }
-    }
+    reorderLiteralFirst(
+      rule,
+      declarations,
+      (decl) => hasVariableReference(decl.value)
+    );
   }
   const literalSeen = /* @__PURE__ */ new Map();
   for (const node of [...rule.nodes]) {
@@ -1234,7 +1367,10 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     };
   }
   if (enableMainChunkTransforms) {
-    p.DeclarationExit = (decl) => normalizeTailwindcssV4Declaration(decl);
+    p.DeclarationExit = (decl) => {
+      normalizeTailwindcssRpxDeclaration(decl, { majorVersion: opts.majorVersion });
+      normalizeTailwindcssV4Declaration(decl);
+    };
     p.AtRuleExit = (atRule) => {
       if (opts.cssRemoveProperty && atRule.name === "property") {
         atRule.remove();
@@ -1460,42 +1596,31 @@ var cssVarsV3_default = [
   }
 ];
 
-// src/mp.ts
-var cssVarsV3Nodes = cssVarsV3_default.map((x) => {
-  return new Declaration2({
-    prop: x.prop,
-    value: x.value
-  });
-});
-function testIfVariablesScope(node, count = 2) {
-  if (isOnlyBeforeAndAfterPseudoElement(node)) {
-    const nodes2 = node.nodes;
-    let c = 0;
-    for (const tryTestDecl of nodes2) {
-      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
-        c++;
-      }
-      if (c >= count) {
+// src/utils/tw-vars.ts
+function hasTwVars(rule, count = 2) {
+  let matched = 0;
+  for (const node of rule.nodes ?? []) {
+    if (node.type === "decl" && node.prop.startsWith("--tw-")) {
+      matched++;
+      if (matched >= count) {
         return true;
       }
     }
-    return false;
+  }
+  return false;
+}
+
+// src/mp.ts
+var cssVarsV3Nodes = createCssVarNodes(cssVarsV3_default);
+function testIfVariablesScope(node, count = 2) {
+  if (isOnlyBeforeAndAfterPseudoElement(node)) {
+    return hasTwVars(node, count);
   }
   return false;
 }
 function testIfTwBackdrop(node, count = 2) {
   if (node.type === "rule" && node.selector === "::backdrop") {
-    const nodes2 = node.nodes;
-    let c = 0;
-    for (const tryTestDecl of nodes2) {
-      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
-        c++;
-      }
-      if (c >= count) {
-        return true;
-      }
-    }
-    return false;
+    return hasTwVars(node, count);
   }
   return false;
 }
@@ -1786,83 +1911,71 @@ function createStylePipeline(options) {
   };
 }
 
-// src/preflight.ts
-function createInjectPreflight(options) {
-  const result = [];
-  if (options && typeof options === "object") {
-    const entries = Object.entries(options);
-    for (const [prop, value] of entries) {
-      if (value !== false) {
-        result.push({
-          prop,
-          value: value.toString()
-        });
-      }
-    }
-  }
-  return () => {
-    return result;
-  };
-}
-
-// src/handler.ts
+// src/processor-cache.ts
 function createProcessOptions(options) {
   return {
     from: void 0,
     ...options.postcssOptions?.options ?? {}
   };
 }
-var pipelineCache = /* @__PURE__ */ new WeakMap();
-var processOptionsCache = /* @__PURE__ */ new WeakMap();
-var processOptionsSourceCache = /* @__PURE__ */ new WeakMap();
-function getCachedPipeline(options) {
-  let pipeline = pipelineCache.get(options);
-  if (!pipeline) {
-    pipeline = createStylePipeline(options);
-    pipelineCache.set(options, pipeline);
-  }
-  return pipeline;
-}
-function getCachedProcessOptions(options) {
-  const source = options.postcssOptions?.options;
-  let cached = processOptionsCache.get(options);
-  const cachedSource = processOptionsSourceCache.get(options);
-  if (!cached || cachedSource !== source) {
-    cached = createProcessOptions(options);
-    processOptionsCache.set(options, cached);
-    processOptionsSourceCache.set(options, source);
-  }
-  return { ...cached };
-}
-function styleHandler(rawSource, options) {
-  const plugins = getCachedPipeline(options).plugins;
-  const processOptions = getCachedProcessOptions(options);
-  return postcss(plugins).process(
-    rawSource,
-    processOptions
-  ).async();
-}
+var StyleProcessorCache = class {
+  pipelineCache = /* @__PURE__ */ new WeakMap();
+  processOptionsCache = /* @__PURE__ */ new WeakMap();
+  processorCache = /* @__PURE__ */ new WeakMap();
+  getPipeline(options) {
+    let pipeline = this.pipelineCache.get(options);
+    if (!pipeline) {
+      pipeline = createStylePipeline(options);
+      this.pipelineCache.set(options, pipeline);
+    }
+    return pipeline;
+  }
+  getProcessOptions(options) {
+    const source = options.postcssOptions?.options;
+    const fingerprint = source ? fingerprintOptions(source) : void 0;
+    const cached = this.processOptionsCache.get(options);
+    if (!cached || cached.fingerprint !== fingerprint) {
+      const created = createProcessOptions(options);
+      this.processOptionsCache.set(options, { value: created, fingerprint });
+      return { ...created };
+    }
+    return { ...cached.value };
+  }
+  getProcessor(options) {
+    let processor = this.processorCache.get(options);
+    if (!processor) {
+      const pipeline = this.getPipeline(options);
+      processor = postcss(pipeline.plugins);
+      this.processorCache.set(options, processor);
+    }
+    return processor;
+  }
+};
+
+// src/handler.ts
 function createStyleHandler(options) {
-  const cachedOptions = defuOverrideArray3(
+  const cachedOptions = defuOverrideArray4(
     options,
     getDefaultOptions(options)
   );
   cachedOptions.cssInjectPreflight = createInjectPreflight(cachedOptions.cssPreflight);
-  getCachedPipeline(cachedOptions);
-  getCachedProcessOptions(cachedOptions);
+  const resolver = createOptionsResolver(cachedOptions);
+  const cache = new StyleProcessorCache();
+  const base = resolver.resolve();
+  cache.getProcessor(base);
+  cache.getProcessOptions(base);
   const handler = ((rawSource, opt) => {
-    const resolvedOptions = defuOverrideArray3(opt, cachedOptions);
-    return styleHandler(
+    const resolvedOptions = resolver.resolve(opt);
+    const processor = cache.getProcessor(resolvedOptions);
+    const processOptions = cache.getProcessOptions(resolvedOptions);
+    return processor.process(
       rawSource,
-      resolvedOptions
-    );
+      processOptions
+    ).async();
   });
   handler.getPipeline = (opt) => {
-    if (!opt) {
-      return getCachedPipeline(cachedOptions);
-    }
-    const resolvedOptions = defuOverrideArray3(opt, cachedOptions);
-    return getCachedPipeline(resolvedOptions);
+    const resolvedOptions = resolver.resolve(opt);
+    return cache.getPipeline(resolvedOptions);
   };
   return handler;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weapp-tailwindcss/postcss",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "@weapp-tailwindcss/postcss",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "dist"
   ],
   "dependencies": {
-    "@weapp-core/escape": "~5.0.1",
+    "@weapp-core/escape": "~6.0.1",
     "@weapp-tailwindcss/postcss-calc": "^1.0.0",
     "postcss": "~8.5.6",
     "postcss-preset-env": "^10.5.0",
@@ -58,6 +58,7 @@
     "dev": "tsup --watch --sourcemap",
     "build": "tsup",
     "test": "vitest run",
+    "bench": "vitest bench",
     "test:dev": "vitest",
     "release": "pnpm publish",
     "lint": "eslint .",