@weapp-tailwindcss/postcss 1.3.0 → 1.3.2-alpha.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import "./chunk-WAXGOBY2.mjs";
 
 // src/handler.ts
-import { defu as defu3, defuOverrideArray as defuOverrideArray3 } from "@weapp-tailwindcss/shared";
+import { defuOverrideArray as defuOverrideArray3 } from "@weapp-tailwindcss/shared";
 import postcss from "postcss";
 
 // src/defaults.ts
@@ -34,25 +34,8 @@ function getDefaultOptions(options) {
   };
 }
 
-// src/plugins/index.ts
-import postcssCalc from "@weapp-tailwindcss/postcss-calc";
-import { defuOverrideArray as defuOverrideArray2, regExpTest } from "@weapp-tailwindcss/shared";
-
-// ../../node_modules/.pnpm/es-toolkit@1.39.10/node_modules/es-toolkit/dist/object/omit.mjs
-function omit(obj, keys) {
-  const result = { ...obj };
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    delete result[key];
-  }
-  return result;
-}
-
 // src/plugins/index.ts
 import postcssPresetEnv from "postcss-preset-env";
-import postcssPxtransform from "postcss-pxtransform";
-import postcssRem2rpx from "postcss-rem-to-responsive-pixel";
-import valueParser from "postcss-value-parser";
 
 // src/plugins/ctx.ts
 function createContext() {
@@ -70,44 +53,171 @@ function createContext() {
   };
 }
 
+// src/plugins/getCalcPlugin.ts
+import postcssCalc from "@weapp-tailwindcss/postcss-calc";
+
+// ../../node_modules/.pnpm/es-toolkit@1.40.0/node_modules/es-toolkit/dist/object/omit.mjs
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    delete result[key];
+  }
+  return result;
+}
+
+// src/plugins/getCalcPlugin.ts
+function getCalcPlugin(options) {
+  if (!options.cssCalc) {
+    return null;
+  }
+  const calcOptions = Array.isArray(options.cssCalc) ? {} : typeof options.cssCalc === "object" ? omit(options.cssCalc, ["includeCustomProperties"]) : {};
+  return postcssCalc(calcOptions);
+}
+
+// src/plugins/getCustomPropertyCleaner.ts
+import { regExpTest } from "@weapp-tailwindcss/shared";
+import valueParser from "postcss-value-parser";
+function getCustomPropertyCleaner(options) {
+  const includeCustomProperties = Array.isArray(options.cssCalc) ? options.cssCalc : typeof options.cssCalc === "object" ? options.cssCalc.includeCustomProperties : [];
+  if (!includeCustomProperties || includeCustomProperties.length === 0) {
+    return null;
+  }
+  return {
+    postcssPlugin: "postcss-remove-include-custom-properties",
+    OnceExit(root) {
+      root.walkDecls((decl, idx) => {
+        if (idx === 0 || !/--/.test(decl.value)) {
+          return;
+        }
+        const prevNode = decl.parent?.nodes[idx - 1];
+        if (!prevNode || prevNode.prop !== decl.prop) {
+          return;
+        }
+        const parsed = valueParser(decl.value);
+        parsed.walk((node) => {
+          if (node.type !== "function" || node.value !== "var") {
+            return;
+          }
+          const match = node.nodes.find((x) => {
+            return x.type === "word" && regExpTest(includeCustomProperties, x.value);
+          });
+          if (match) {
+            decl.remove();
+          }
+        });
+      });
+    }
+  };
+}
+
+// src/plugins/getPxTransformPlugin.ts
+import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+import postcssPxtransform from "postcss-pxtransform";
+var defaultPxTransformOptions = {
+  platform: "weapp",
+  unitPrecision: 5,
+  propList: ["*"],
+  selectorBlackList: [],
+  replace: true,
+  mediaQuery: false,
+  minPixelValue: 0,
+  designWidth: 750,
+  deviceRatio: {
+    375: 2,
+    640: 2.34 / 2,
+    750: 1,
+    828: 1.81 / 2
+  }
+};
+function getPxTransformPlugin(options) {
+  if (!options.px2rpx) {
+    return null;
+  }
+  const userOptions = typeof options.px2rpx === "object" ? options.px2rpx : {};
+  return postcssPxtransform(
+    defuOverrideArray(
+      userOptions,
+      defaultPxTransformOptions
+    )
+  );
+}
+
+// src/plugins/getRemTransformPlugin.ts
+import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
+import postcssRem2rpx from "postcss-rem-to-responsive-pixel";
+var defaultRemOptions = {
+  rootValue: 32,
+  propList: ["*"],
+  transformUnit: "rpx"
+};
+var defaultStage = {
+  processorStage: "OnceExit"
+};
+function getRemTransformPlugin(options) {
+  if (!options.rem2rpx) {
+    return null;
+  }
+  const userOptions = typeof options.rem2rpx === "object" ? options.rem2rpx : defaultRemOptions;
+  const merged = defuOverrideArray2(
+    userOptions,
+    defaultStage
+  );
+  return postcssRem2rpx(merged);
+}
+
 // src/plugins/post.ts
 import { defu } from "@weapp-tailwindcss/shared";
 
 // src/constants.ts
 var postcssPlugin = "postcss-weapp-tailwindcss-rename-plugin";
 
-// src/selectorParser.ts
-import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+// src/selectorParser/before-after.ts
 import psp from "postcss-selector-parser";
-
-// src/shared.ts
-import { escape, MappingChars2String } from "@weapp-core/escape";
-function internalCssSelectorReplacer(selectors, options = {
-  escapeMap: MappingChars2String
-}) {
-  const { mangleContext, escapeMap } = options;
-  if (mangleContext) {
-    selectors = mangleContext.cssHandler(selectors);
+var beforeAfterStateRef = null;
+var beforeAfterParser = psp((selectors) => {
+  const state = beforeAfterStateRef;
+  if (!state) {
+    return;
   }
-  return escape(selectors, {
-    map: escapeMap
+  selectors.walkPseudos((s) => {
+    if (s.parent?.length === 1) {
+      if (/^:?:before$/.test(s.value)) {
+        state.before = true;
+      }
+      if (/^:?:after$/.test(s.value)) {
+        state.after = true;
+      }
+    }
   });
-}
-function composeIsPseudo(strs) {
-  if (typeof strs === "string") {
-    return strs;
-  }
-  if (strs.length > 1) {
-    return `:is(${strs.join(",")})`;
-  }
-  return strs.join("");
+});
+function isOnlyBeforeAndAfterPseudoElement(node) {
+  const state = {
+    before: false,
+    after: false
+  };
+  beforeAfterStateRef = state;
+  beforeAfterParser.astSync(node);
+  beforeAfterStateRef = null;
+  return state.before && state.after;
 }
 
-// src/selectorParser.ts
+// src/selectorParser/fallback.ts
+import psp3 from "postcss-selector-parser";
+
+// src/selectorParser/utils.ts
+import psp2 from "postcss-selector-parser";
+function normalizeTransformOptions(options) {
+  return {
+    lossless: false,
+    updateSelector: true,
+    ...options
+  };
+}
 function mklist(node) {
   return [
     node,
-    psp.combinator({
+    psp2.combinator({
       value: "+"
     }),
     node.clone()
@@ -115,35 +225,166 @@ function mklist(node) {
 }
 function composeIsPseudoAst(strs) {
   if (typeof strs === "string") {
-    return mklist(psp.tag({
+    return mklist(psp2.tag({
       value: strs
     }));
   }
   if (strs.length > 1) {
-    return mklist(psp.pseudo({
+    return mklist(psp2.pseudo({
       value: ":is",
       nodes: strs.map(
-        (str) => psp.tag({
+        (str) => psp2.tag({
           value: str
         })
       )
     }));
   }
-  return mklist(psp.tag({
+  return mklist(psp2.tag({
     value: strs[0]
   }));
 }
 function getCombinatorSelectorAst(options) {
-  let childCombinatorReplaceValue = mklist(psp.tag({ value: "view" }));
+  let childCombinatorReplaceValue = mklist(psp2.tag({ value: "view" }));
   const { cssChildCombinatorReplaceValue } = options;
   if (typeof cssChildCombinatorReplaceValue === "string" || Array.isArray(cssChildCombinatorReplaceValue) && cssChildCombinatorReplaceValue.length > 0) {
     childCombinatorReplaceValue = composeIsPseudoAst(cssChildCombinatorReplaceValue);
   }
   return childCombinatorReplaceValue;
 }
-function createRuleTransform(rule, options) {
+
+// src/selectorParser/fallback.ts
+var fallbackRemoveCache = /* @__PURE__ */ new WeakMap();
+var fallbackDefaultKey = {};
+function getFallbackRemove(_rule, options) {
+  const cacheKey = options ?? fallbackDefaultKey;
+  let entry = fallbackRemoveCache.get(cacheKey);
+  if (!entry) {
+    const uniAppX = Boolean(options?.uniAppX);
+    let currentRule;
+    const parser = psp3((selectors) => {
+      const activeRule = currentRule;
+      let maybeImportantId = false;
+      selectors.walk((selector, idx) => {
+        if (idx === 0 && (selector.type === "id" || selector.type === "class" || selector.type === "attribute")) {
+          maybeImportantId = true;
+        }
+        if (selector.type === "universal") {
+          selector.parent?.remove();
+        } else if (selector.type === "pseudo") {
+          if (selector.value === ":is") {
+            if (maybeImportantId && selector.nodes[0]?.type === "selector") {
+              selector.replaceWith(selector.nodes[0]);
+            } else {
+              selector.parent?.remove();
+            }
+          } else if (selector.value === ":not") {
+            for (const x of selector.nodes) {
+              if (x.nodes.length === 1 && x.nodes[0].type === "id" && x.nodes[0].value === "#") {
+                x.nodes = [
+                  psp3.tag({
+                    value: "#n"
+                  })
+                ];
+              }
+            }
+          } else if (selector.value === ":where") {
+            for (const n of selector.nodes) {
+              for (const node of n.nodes) {
+                if (node.type === "attribute") {
+                  node.remove();
+                }
+              }
+            }
+          }
+        } else if (selector.type === "attribute") {
+          if (selector.attribute === "hidden") {
+            activeRule?.remove();
+          }
+        }
+      });
+      selectors.walk((selector) => {
+        if (selector.type === "pseudo") {
+          if (selector.value === ":where") {
+            const res = selector.nodes.every((x) => x.nodes.length === 0);
+            if (res) {
+              selector.remove();
+            }
+          } else if (selector.type === "pseudo") {
+            if (uniAppX) {
+              selector.remove();
+            }
+          }
+        }
+      });
+    });
+    const rawTransformSync = parser.transformSync.bind(parser);
+    const transform = (targetRule) => {
+      currentRule = targetRule;
+      try {
+        rawTransformSync(targetRule, normalizeTransformOptions());
+      } finally {
+        currentRule = void 0;
+      }
+    };
+    parser.transformSync = ((input, opts) => {
+      if (input && typeof input === "object" && "type" in input) {
+        const maybeRule = input;
+        if (maybeRule.type === "rule") {
+          currentRule = input;
+          try {
+            return rawTransformSync(input, normalizeTransformOptions(opts));
+          } finally {
+            currentRule = void 0;
+          }
+        }
+      }
+      return rawTransformSync(input, opts);
+    });
+    entry = {
+      parser,
+      transform
+    };
+    fallbackRemoveCache.set(cacheKey, entry);
+  }
+  return entry.parser;
+}
+
+// src/selectorParser/rule-transformer.ts
+import psp4 from "postcss-selector-parser";
+
+// src/shared.ts
+import { escape, MappingChars2String } from "@weapp-core/escape";
+function internalCssSelectorReplacer(selectors, options = {
+  escapeMap: MappingChars2String
+}) {
+  const { mangleContext, escapeMap } = options;
+  if (mangleContext) {
+    selectors = mangleContext.cssHandler(selectors);
+  }
+  return escape(selectors, {
+    map: escapeMap
+  });
+}
+function composeIsPseudo(strs) {
+  if (typeof strs === "string") {
+    return strs;
+  }
+  if (strs.length > 1) {
+    return `:is(${strs.join(",")})`;
+  }
+  return strs.join("");
+}
+
+// src/selectorParser/rule-transformer.ts
+var ruleTransformCache = /* @__PURE__ */ new WeakMap();
+function createRuleTransformer(options) {
+  let currentRule;
   const { escapeMap, mangleContext, cssSelectorReplacement, cssRemoveHoverPseudoClass, uniAppX } = options;
   const transform = (selectors) => {
+    const rule = currentRule;
+    if (!rule) {
+      return;
+    }
     selectors.walk((selector, index) => {
       if (selector.type === "class") {
         selector.value = internalCssSelectorReplacer(selector.value, {
@@ -252,90 +493,23 @@ function createRuleTransform(rule, options) {
       rule.remove();
     }
   };
-  return transform;
+  const parser = psp4(transform);
+  return (rule) => {
+    currentRule = rule;
+    try {
+      parser.transformSync(rule, normalizeTransformOptions());
+    } finally {
+      currentRule = void 0;
+    }
+  };
 }
 function ruleTransformSync(rule, options) {
-  const transformer = psp(createRuleTransform(rule, options));
-  return transformer.transformSync(rule, {
-    lossless: false,
-    updateSelector: true
-  });
-}
-function isOnlyBeforeAndAfterPseudoElement(node) {
-  let b = false;
-  let a = false;
-  psp((selectors) => {
-    selectors.walkPseudos((s) => {
-      if (s.parent?.length === 1) {
-        if (/^:?:before$/.test(s.value)) {
-          b = true;
-        }
-        if (/^:?:after$/.test(s.value)) {
-          a = true;
-        }
-      }
-    });
-  }).astSync(node);
-  return b && a;
-}
-function getFallbackRemove(rule, options) {
-  const { uniAppX } = defuOverrideArray(options, {});
-  const fallbackRemove = psp((selectors) => {
-    let maybeImportantId = false;
-    selectors.walk((selector, idx) => {
-      if (idx === 0 && (selector.type === "id" || selector.type === "class" || selector.type === "attribute")) {
-        maybeImportantId = true;
-      }
-      if (selector.type === "universal") {
-        selector.parent?.remove();
-      } else if (selector.type === "pseudo") {
-        if (selector.value === ":is") {
-          if (maybeImportantId && selector.nodes[0]?.type === "selector") {
-            selector.replaceWith(selector.nodes[0]);
-          } else {
-            selector.parent?.remove();
-          }
-        } else if (selector.value === ":not") {
-          for (const x of selector.nodes) {
-            if (x.nodes.length === 1 && x.nodes[0].type === "id" && x.nodes[0].value === "#") {
-              x.nodes = [
-                psp.tag({
-                  value: "#n"
-                })
-              ];
-            }
-          }
-        } else if (selector.value === ":where") {
-          for (const n of selector.nodes) {
-            for (const node of n.nodes) {
-              if (node.type === "attribute") {
-                node.remove();
-              }
-            }
-          }
-        }
-      } else if (selector.type === "attribute") {
-        if (selector.attribute === "hidden") {
-          rule?.remove();
-        }
-      }
-    });
-    selectors.walk((selector) => {
-      if (selector.type === "pseudo") {
-        if (selector.value === ":where") {
-          const res = selector.nodes.every((x) => x.nodes.length === 0);
-          if (res) {
-            selector.remove();
-          }
-        } else if (selector.type === "pseudo") {
-          if (uniAppX) {
-            selector.remove();
-          }
-        }
-      }
-    });
-  });
-  return fallbackRemove;
+  let transformer = ruleTransformCache.get(options);
+  if (!transformer) {
+    transformer = createRuleTransformer(options);
+    ruleTransformCache.set(options, transformer);
+  }
+  transformer(rule);
 }
 
 // src/plugins/post.ts
@@ -348,11 +522,9 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     postcssPlugin
   };
   if (opts.isMainChunk) {
+    const fallbackRemove = getFallbackRemove(void 0, opts);
     p.RuleExit = (rule) => {
-      getFallbackRemove(rule, opts).transformSync(rule, {
-        updateSelector: true,
-        lossless: false
-      });
+      fallbackRemove.transformSync(rule);
       if (rule.selectors.length === 0 || rule.selectors.length === 1 && rule.selector.trim() === "") {
         rule.remove();
       }
@@ -914,96 +1086,36 @@ postcssWeappTailwindcssPrePlugin.postcss = true;
 
 // src/plugins/index.ts
 import { default as default2 } from "postcss-rem-to-responsive-pixel";
+function normalizePlugins(options) {
+  const plugins = [];
+  const pxPlugin = getPxTransformPlugin(options);
+  if (pxPlugin) {
+    plugins.push(pxPlugin);
+  }
+  const remPlugin = getRemTransformPlugin(options);
+  if (remPlugin) {
+    plugins.push(remPlugin);
+  }
+  const calcPlugin = getCalcPlugin(options);
+  if (calcPlugin) {
+    plugins.push(calcPlugin);
+  }
+  const customPropertyCleaner = getCustomPropertyCleaner(options);
+  if (customPropertyCleaner) {
+    plugins.push(customPropertyCleaner);
+  }
+  return plugins;
+}
 function getPlugins(options) {
   const ctx = createContext();
   options.ctx = ctx;
   const plugins = [
     ...options.postcssOptions?.plugins ?? [],
-    postcssWeappTailwindcssPrePlugin(options)
-  ].filter((x) => Boolean(x));
-  plugins.push(
-    // https://preset-env.cssdb.org/
-    // https://github.com/csstools/postcss-plugins/tree/main/plugin-packs/postcss-preset-env#readme
-    postcssPresetEnv(
-      options.cssPresetEnv
-    )
-  );
-  if (options.px2rpx) {
-    plugins.push(
-      postcssPxtransform(
-        defuOverrideArray2(
-          typeof options.px2rpx === "object" ? options.px2rpx : {},
-          {
-            platform: "weapp",
-            unitPrecision: 5,
-            propList: ["*"],
-            selectorBlackList: [],
-            replace: true,
-            mediaQuery: false,
-            minPixelValue: 0,
-            designWidth: 750,
-            deviceRatio: {
-              375: 2,
-              640: 2.34 / 2,
-              750: 1,
-              828: 1.81 / 2
-            }
-          }
-        )
-      )
-    );
-  }
-  if (options.rem2rpx) {
-    plugins.push(
-      postcssRem2rpx(
-        defuOverrideArray2(
-          typeof options.rem2rpx === "object" ? options.rem2rpx : {
-            rootValue: 32,
-            propList: ["*"],
-            transformUnit: "rpx"
-          },
-          {
-            processorStage: "OnceExit"
-          }
-        )
-      )
-    );
-  }
-  const includeCustomProperties = Array.isArray(options.cssCalc) ? options.cssCalc : typeof options.cssCalc === "object" ? options.cssCalc.includeCustomProperties : [];
-  if (options.cssCalc) {
-    plugins.push(
-      // 核心在 OnceExit 的时候去执行的
-      postcssCalc(
-        Array.isArray(options.cssCalc) ? {} : typeof options.cssCalc === "object" ? omit(options.cssCalc, ["includeCustomProperties"]) : {}
-      )
-    );
-  }
-  plugins.push(postcssWeappTailwindcssPostPlugin(options));
-  if (includeCustomProperties) {
-    plugins.push({
-      postcssPlugin: "postcss-remove-include-custom-properties",
-      OnceExit(root) {
-        root.walkDecls((decl, idx) => {
-          if (idx > 0 && regExpTest(includeCustomProperties, decl.value)) {
-            const prevNode = decl.parent?.nodes[idx - 1];
-            if (prevNode && prevNode.prop === decl.prop) {
-              const parsed = valueParser(decl.value);
-              parsed.walk((node) => {
-                if (node.type === "function" && node.value === "var") {
-                  const item = node.nodes.find((x) => {
-                    return x.type === "word" && regExpTest(includeCustomProperties, x.value);
-                  });
-                  if (item) {
-                    decl.remove();
-                  }
-                }
-              });
-            }
-          }
-        });
-      }
-    });
-  }
+    postcssWeappTailwindcssPrePlugin(options),
+    postcssPresetEnv(options.cssPresetEnv),
+    ...normalizePlugins(options),
+    postcssWeappTailwindcssPostPlugin(options)
+  ].filter(Boolean);
   return plugins;
 }
 
@@ -1027,14 +1139,40 @@ function createInjectPreflight(options) {
 }
 
 // src/handler.ts
+function createProcessOptions(options) {
+  return {
+    from: void 0,
+    ...options.postcssOptions?.options ?? {}
+  };
+}
+var pluginCache = /* @__PURE__ */ new WeakMap();
+var processOptionsCache = /* @__PURE__ */ new WeakMap();
+var processOptionsSourceCache = /* @__PURE__ */ new WeakMap();
+function getCachedPlugins(options) {
+  let plugins = pluginCache.get(options);
+  if (!plugins) {
+    plugins = getPlugins(options);
+    pluginCache.set(options, plugins);
+  }
+  return plugins;
+}
+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) {
-  return postcss(
-    getPlugins(options)
-  ).process(
+  const plugins = getCachedPlugins(options);
+  const processOptions = getCachedProcessOptions(options);
+  return postcss(plugins).process(
     rawSource,
-    defu3(options.postcssOptions?.options, {
-      from: void 0
-    })
+    processOptions
   ).async();
 }
 function createStyleHandler(options) {
@@ -1043,10 +1181,13 @@ function createStyleHandler(options) {
     getDefaultOptions(options)
   );
   cachedOptions.cssInjectPreflight = createInjectPreflight(cachedOptions.cssPreflight);
+  getCachedPlugins(cachedOptions);
+  getCachedProcessOptions(cachedOptions);
   return (rawSource, opt) => {
+    const resolvedOptions = defuOverrideArray3(opt, cachedOptions);
     return styleHandler(
       rawSource,
-      defuOverrideArray3(opt, cachedOptions)
+      resolvedOptions
     );
   };
 }