weapp-tailwindcss 3.7.0 → 3.8.0-alpha.1

package/dist/chunk-HBQASQKY.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/debug/index.ts
+var _debug2 = require('debug'); var _debug3 = _interopRequireDefault(_debug2);
+var _debug = _debug3.default.call(void 0, "weapp-tw");
+function createDebug(prefix) {
+  function debug(formatter, ...args) {
+    return _debug((prefix != null ? prefix : "") + formatter, ...args);
+  }
+  return debug;
+}
+
+
+
+exports.createDebug = createDebug;

package/dist/chunk-IETFIAKJ.js

@@ -0,0 +1,152 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkHBQASQKYjs = require('./chunk-HBQASQKY.js');
+
+
+var _chunkLWRZXI5Tjs = require('./chunk-LWRZXI5T.js');
+
+
+
+var _chunk6FNC3XMIjs = require('./chunk-6FNC3XMI.js');
+
+// src/bundlers/gulp/index.ts
+var _buffer = require('buffer');
+var _stream = require('stream'); var _stream2 = _interopRequireDefault(_stream);
+var debug = _chunkHBQASQKYjs.createDebug.call(void 0, );
+var Transform = _stream2.default.Transform;
+function createPlugins(options = {}) {
+  const opts = _chunkLWRZXI5Tjs.getOptions.call(void 0, options);
+  const { templateHandler, styleHandler, patch, jsHandler, setMangleRuntimeSet, cache, twPatcher } = opts;
+  let runtimeSet = /* @__PURE__ */ new Set();
+  patch == null ? void 0 : patch();
+  function transformWxss(options2 = {}) {
+    return new Transform({
+      objectMode: true,
+      transform(file, _encoding, callback) {
+        return _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+          runtimeSet = twPatcher.getClassSet();
+          setMangleRuntimeSet(runtimeSet);
+          const error = null;
+          if (file.contents) {
+            const rawSource = file.contents.toString();
+            const hash = cache.computeHash(rawSource);
+            cache.calcHashValueChanged(file.path, hash);
+            yield cache.process(
+              file.path,
+              () => {
+                const source = cache.get(file.path);
+                if (source) {
+                  file.contents = _buffer.Buffer.from(source);
+                  debug("css cache hit: %s", file.path);
+                } else {
+                  return false;
+                }
+              },
+              () => _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+                const { css } = yield styleHandler(rawSource, _chunk6FNC3XMIjs.__spreadValues.call(void 0, {
+                  isMainChunk: true
+                }, options2));
+                file.contents = _buffer.Buffer.from(css);
+                debug("css handle: %s", file.path);
+                return {
+                  key: file.path,
+                  source: css
+                };
+              })
+            );
+          }
+          callback(error, file);
+        });
+      }
+      // construct(callback) {
+      //   debug('transformWxss start')
+      //   callback()
+      // }
+    });
+  }
+  function transformJs(options2 = {}) {
+    return new Transform({
+      objectMode: true,
+      transform(file, _encoding, callback) {
+        return _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+          const error = null;
+          if (file.contents) {
+            const rawSource = file.contents.toString();
+            const hash = cache.computeHash(rawSource);
+            cache.calcHashValueChanged(file.path, hash);
+            yield cache.process(
+              file.path,
+              () => {
+                const source = cache.get(file.path);
+                if (source) {
+                  file.contents = _buffer.Buffer.from(source);
+                  debug("js cache hit: %s", file.path);
+                } else {
+                  return false;
+                }
+              },
+              () => _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+                const { code } = yield jsHandler(rawSource, runtimeSet, options2);
+                file.contents = _buffer.Buffer.from(code);
+                debug("js handle: %s", file.path);
+                return {
+                  key: file.path,
+                  source: code
+                };
+              })
+            );
+          }
+          callback(error, file);
+        });
+      }
+    });
+  }
+  function transformWxml(options2 = {}) {
+    return new Transform({
+      objectMode: true,
+      transform(file, _encoding, callback) {
+        return _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+          const error = null;
+          if (file.contents) {
+            const rawSource = file.contents.toString();
+            const hash = cache.computeHash(rawSource);
+            cache.calcHashValueChanged(file.path, hash);
+            yield cache.process(
+              file.path,
+              () => {
+                const source = cache.get(file.path);
+                if (source) {
+                  file.contents = _buffer.Buffer.from(source);
+                  debug("html cache hit: %s", file.path);
+                } else {
+                  return false;
+                }
+              },
+              () => _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+                const code = yield templateHandler(rawSource, _chunk6FNC3XMIjs.__spreadValues.call(void 0, {
+                  runtimeSet
+                }, options2));
+                file.contents = _buffer.Buffer.from(code);
+                debug("html handle: %s", file.path);
+                return {
+                  key: file.path,
+                  source: code
+                };
+              })
+            );
+          }
+          callback(error, file);
+        });
+      }
+    });
+  }
+  return {
+    transformWxss,
+    transformWxml,
+    transformJs
+  };
+}
+
+
+
+exports.createPlugins = createPlugins;

package/dist/chunk-KE7J6XFD.mjs

@@ -0,0 +1,537 @@
+import {
+  composeIsPseudo,
+  internalCssSelectorReplacer
+} from "./chunk-VKSQ6BRD.mjs";
+
+// src/constants.ts
+var postcssPlugin = "postcss-weapp-tailwindcss-rename-plugin";
+var pluginName = "weapp-tailwindcss-webpack-plugin";
+var vitePluginName = "vite-plugin-uni-app-weapp-tailwindcss-adaptor";
+var WEAPP_TW_REQUIRED_NODE_VERSION = "18.17.0";
+
+// src/postcss/selectorParser.ts
+import selectorParser from "postcss-selector-parser";
+function createRuleTransform(rule, options) {
+  const { escapeMap, mangleContext, cssSelectorReplacement, cssRemoveHoverPseudoClass } = options;
+  const transform = (selectors) => {
+    selectors.walk((selector) => {
+      if (selector.type === "universal" && (cssSelectorReplacement == null ? void 0 : cssSelectorReplacement.universal)) {
+        selector.value = composeIsPseudo(cssSelectorReplacement.universal);
+      }
+      if (cssRemoveHoverPseudoClass && selector.type === "selector") {
+        const node = selector.nodes.find((x) => x.type === "pseudo" && x.value === ":hover");
+        if (node) {
+          selector.remove();
+        }
+      }
+      if (selector.type === "pseudo" && selector.value === ":root" && (cssSelectorReplacement == null ? void 0 : cssSelectorReplacement.root)) {
+        selector.value = composeIsPseudo(cssSelectorReplacement.root);
+      }
+      if (selector.type === "class") {
+        selector.value = internalCssSelectorReplacer(selector.value, {
+          escapeMap,
+          mangleContext
+        });
+      }
+    });
+    if (selectors.length === 0) {
+      rule.remove();
+    }
+  };
+  return transform;
+}
+function getRuleTransformer(rule, options) {
+  return selectorParser(createRuleTransform(rule, options));
+}
+function ruleTransformSync(rule, options) {
+  const transformer = getRuleTransformer(rule, options);
+  return transformer.transformSync(rule, {
+    lossless: false,
+    updateSelector: true
+  });
+}
+function isOnlyBeforeAndAfterPseudoElement(node) {
+  let b = false;
+  let a = false;
+  selectorParser((selectors) => {
+    selectors.walkPseudos((s) => {
+      var _a;
+      if (((_a = s.parent) == null ? void 0 : _a.length) === 1) {
+        if (/^:?:before$/.test(s.value)) {
+          b = true;
+        }
+        if (/^:?:after$/.test(s.value)) {
+          a = true;
+        }
+      }
+    });
+  }).astSync(node);
+  return b && a;
+}
+var fallbackRemove = selectorParser((selectors) => {
+  let maybeImportantId = false;
+  selectors.walk((selector, idx) => {
+    var _a, _b, _c;
+    if (idx === 0 && (selector.type === "id" || selector.type === "class" || selector.type === "attribute")) {
+      maybeImportantId = true;
+    }
+    if (selector.type === "universal") {
+      (_a = selector.parent) == null ? void 0 : _a.remove();
+    }
+    if (selector.type === "pseudo" && selector.value === ":is") {
+      if (maybeImportantId && ((_b = selector.nodes[0]) == null ? void 0 : _b.type) === "selector") {
+        selector.replaceWith(selector.nodes[0]);
+      } else {
+        (_c = selector.parent) == null ? void 0 : _c.remove();
+      }
+    }
+  });
+});
+
+// src/postcss/plugins/post.ts
+var postcssWeappTailwindcssPostPlugin = (options = {
+  isMainChunk: true
+}) => {
+  const { customRuleCallback, isMainChunk } = options;
+  const p = {
+    postcssPlugin
+  };
+  if (isMainChunk) {
+    p.OnceExit = (root) => {
+      root.walkRules((rule) => {
+        fallbackRemove.transformSync(rule, {
+          updateSelector: true,
+          lossless: false
+        });
+        if (rule.selectors.length === 0 || rule.selectors.length === 1 && rule.selector.trim() === "") {
+          rule.remove();
+        }
+      });
+    };
+  }
+  if (typeof customRuleCallback === "function") {
+    p.Rule = (rule) => {
+      customRuleCallback(rule, options);
+    };
+  }
+  return p;
+};
+postcssWeappTailwindcssPostPlugin.postcss = true;
+
+// src/postcss/mp.ts
+import { Declaration, Rule } from "postcss";
+
+// src/postcss/cssVars.ts
+var cssVars_default = [
+  {
+    prop: "--tw-border-spacing-x",
+    value: "0"
+  },
+  {
+    prop: "--tw-border-spacing-y",
+    value: "0"
+  },
+  {
+    prop: "--tw-translate-x",
+    value: "0"
+  },
+  {
+    prop: "--tw-translate-y",
+    value: "0"
+  },
+  {
+    prop: "--tw-rotate",
+    value: "0"
+  },
+  {
+    prop: "--tw-skew-x",
+    value: "0"
+  },
+  {
+    prop: "--tw-skew-y",
+    value: "0"
+  },
+  {
+    prop: "--tw-scale-x",
+    value: "1"
+  },
+  {
+    prop: "--tw-scale-y",
+    value: "1"
+  },
+  {
+    prop: "--tw-pan-x",
+    value: " "
+  },
+  {
+    prop: "--tw-pan-y",
+    value: " "
+  },
+  {
+    prop: "--tw-pinch-zoom",
+    value: " "
+  },
+  {
+    prop: "--tw-scroll-snap-strictness",
+    value: "proximity"
+  },
+  {
+    prop: "--tw-gradient-from-position",
+    value: " "
+  },
+  {
+    prop: "--tw-gradient-via-position",
+    value: " "
+  },
+  {
+    prop: "--tw-gradient-to-position",
+    value: " "
+  },
+  {
+    prop: "--tw-ordinal",
+    value: " "
+  },
+  {
+    prop: "--tw-slashed-zero",
+    value: " "
+  },
+  {
+    prop: "--tw-numeric-figure",
+    value: " "
+  },
+  {
+    prop: "--tw-numeric-spacing",
+    value: " "
+  },
+  {
+    prop: "--tw-numeric-fraction",
+    value: " "
+  },
+  {
+    prop: "--tw-ring-inset",
+    value: " "
+  },
+  {
+    prop: "--tw-ring-offset-width",
+    value: "0px"
+  },
+  {
+    prop: "--tw-ring-offset-color",
+    value: "#fff"
+  },
+  {
+    prop: "--tw-ring-color",
+    value: "rgb(59 130 246 / 0.5)"
+  },
+  {
+    prop: "--tw-ring-offset-shadow",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-ring-shadow",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-shadow",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-shadow-colored",
+    value: "0 0 #0000"
+  },
+  {
+    prop: "--tw-blur",
+    value: " "
+  },
+  {
+    prop: "--tw-brightness",
+    value: " "
+  },
+  {
+    prop: "--tw-contrast",
+    value: " "
+  },
+  {
+    prop: "--tw-grayscale",
+    value: " "
+  },
+  {
+    prop: "--tw-hue-rotate",
+    value: " "
+  },
+  {
+    prop: "--tw-invert",
+    value: " "
+  },
+  {
+    prop: "--tw-saturate",
+    value: " "
+  },
+  {
+    prop: "--tw-sepia",
+    value: " "
+  },
+  {
+    prop: "--tw-drop-shadow",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-blur",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-brightness",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-contrast",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-grayscale",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-hue-rotate",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-invert",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-opacity",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-saturate",
+    value: " "
+  },
+  {
+    prop: "--tw-backdrop-sepia",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-size",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-layout",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-paint",
+    value: " "
+  },
+  {
+    prop: "--tw-contain-style",
+    value: " "
+  }
+];
+
+// src/postcss/mp.ts
+var initialNodes = cssVars_default.map((x) => {
+  return new Declaration({
+    prop: x.prop,
+    value: x.value
+  });
+});
+var PATTERNS = [
+  /:not\(template\)\s*[~+]\s*:not\(template\)/.source,
+  /:not\(\[hidden\]\)\s*[~+]\s*:not\(\[hidden\]\)/.source
+].join("|");
+var BROAD_MATCH_GLOBAL_REGEXP = new RegExp(PATTERNS, "g");
+function testIfVariablesScope(node, count = 2) {
+  if (isOnlyBeforeAndAfterPseudoElement(node)) {
+    const nodes = node.nodes;
+    let c = 0;
+    for (const tryTestDecl of nodes) {
+      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
+        c++;
+      }
+      if (c >= count) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return false;
+}
+function testIfTwBackdrop(node, count = 2) {
+  if (node.type === "rule" && node.selector === "::backdrop") {
+    const nodes = node.nodes;
+    let c = 0;
+    for (const tryTestDecl of nodes) {
+      if (tryTestDecl && tryTestDecl.type === "decl" && tryTestDecl.prop.startsWith("--tw-")) {
+        c++;
+      }
+      if (c >= count) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return false;
+}
+function makePseudoVarRule() {
+  const pseudoVarRule = new Rule({
+    // selectors: ['::before', '::after'],
+    selector: "::before,::after"
+  });
+  pseudoVarRule.append(
+    new Declaration({
+      prop: "--tw-content",
+      value: '""'
+    })
+  );
+  return pseudoVarRule;
+}
+function remakeCssVarSelector(selectors, options) {
+  const { cssPreflightRange, cssSelectorReplacement } = options;
+  if (cssPreflightRange === "all" && !selectors.includes(":not(not)")) {
+    selectors.push(":not(not)");
+  }
+  if (cssSelectorReplacement) {
+    if (Array.isArray(cssSelectorReplacement.universal)) {
+      if (!cssSelectorReplacement.universal.every((x) => {
+        return selectors.includes(x);
+      }) && !selectors.includes("*")) {
+        selectors.unshift("*");
+      }
+    } else if (typeof cssSelectorReplacement.universal === "string" && !selectors.includes(cssSelectorReplacement.universal) && !selectors.includes("*")) {
+      selectors.unshift("*");
+    }
+  }
+  return selectors;
+}
+function remakeCombinatorSelector(selector, cssChildCombinatorReplaceValue) {
+  let childCombinatorReplaceValue = "view + view";
+  if (Array.isArray(cssChildCombinatorReplaceValue) && cssChildCombinatorReplaceValue.length > 0) {
+    const x = composeIsPseudo(cssChildCombinatorReplaceValue);
+    childCombinatorReplaceValue = `${x} + ${x}`;
+  } else if (typeof cssChildCombinatorReplaceValue === "string") {
+    childCombinatorReplaceValue = cssChildCombinatorReplaceValue;
+  }
+  return selector.replaceAll(BROAD_MATCH_GLOBAL_REGEXP, childCombinatorReplaceValue);
+}
+function commonChunkPreflight(node, options) {
+  const { ctx, cssChildCombinatorReplaceValue, cssInjectPreflight, injectAdditionalCssVarScope } = options;
+  node.selector = remakeCombinatorSelector(node.selector, cssChildCombinatorReplaceValue);
+  if (testIfVariablesScope(node)) {
+    ctx == null ? void 0 : ctx.markVariablesScope(node);
+    node.selectors = remakeCssVarSelector(node.selectors, options);
+    node.before(makePseudoVarRule());
+    if (typeof cssInjectPreflight === "function") {
+      node.append(...cssInjectPreflight());
+    }
+  }
+  if (injectAdditionalCssVarScope && testIfTwBackdrop(node)) {
+    const syntheticRule = new Rule({
+      selectors: ["*", "::after", "::before"],
+      nodes: initialNodes
+    });
+    syntheticRule.selectors = remakeCssVarSelector(syntheticRule.selectors, options);
+    node.before(syntheticRule);
+    node.before(makePseudoVarRule());
+    if (typeof cssInjectPreflight === "function") {
+      syntheticRule.append(...cssInjectPreflight());
+    }
+  }
+}
+
+// src/postcss/plugins/pre.ts
+function isAtMediaHover(atRule) {
+  return /media\(\s*hover\s*:\s*hover\s*\)/.test(atRule.name) || atRule.name === "media" && /\(\s*hover\s*:\s*hover\s*\)/.test(atRule.params);
+}
+var postcssWeappTailwindcssPrePlugin = (options = {
+  isMainChunk: true
+}) => {
+  const { isMainChunk } = options;
+  const p = {
+    postcssPlugin,
+    Rule(rule) {
+      ruleTransformSync(rule, options);
+    },
+    AtRule(atRule) {
+      if (isAtMediaHover(atRule)) {
+        if (atRule.nodes) {
+          atRule.replaceWith(atRule.nodes);
+        } else {
+          atRule.remove();
+        }
+      }
+    }
+  };
+  if (isMainChunk) {
+    p.Once = (root) => {
+      root.walkRules((rule) => {
+        commonChunkPreflight(rule, options);
+      });
+    };
+  }
+  return p;
+};
+postcssWeappTailwindcssPrePlugin.postcss = true;
+
+// src/postcss/plugins/index.ts
+import postcssIsPseudoClass from "@csstools/postcss-is-pseudo-class";
+import postcssRem2rpx from "postcss-rem-to-responsive-pixel";
+
+// src/postcss/symbols.ts
+var VariablesScopeSymbol = Symbol("VariablesScope");
+
+// src/postcss/plugins/ctx.ts
+function createContext() {
+  const variablesScopeWeakMap = /* @__PURE__ */ new WeakMap();
+  function isVariablesScope(rule) {
+    return variablesScopeWeakMap.get(rule) === VariablesScopeSymbol;
+  }
+  function markVariablesScope(rule) {
+    variablesScopeWeakMap.set(rule, VariablesScopeSymbol);
+  }
+  return {
+    variablesScopeWeakMap,
+    isVariablesScope,
+    markVariablesScope
+  };
+}
+
+// src/postcss/plugins/index.ts
+import { default as default2 } from "@csstools/postcss-is-pseudo-class";
+import { default as default3 } from "postcss-rem-to-responsive-pixel";
+function getPlugins(options) {
+  var _a, _b;
+  const ctx = createContext();
+  options.ctx = ctx;
+  const plugins = [
+    ...(_b = (_a = options.postcssOptions) == null ? void 0 : _a.plugins) != null ? _b : [],
+    postcssWeappTailwindcssPrePlugin(options),
+    postcssIsPseudoClass({
+      specificityMatchingName: "weapp-tw-ig"
+    })
+  ];
+  if (options.rem2rpx) {
+    plugins.push(
+      postcssRem2rpx(
+        typeof options.rem2rpx === "object" ? options.rem2rpx : {
+          rootValue: 32,
+          propList: ["*"],
+          transformUnit: "rpx"
+        }
+      )
+    );
+  }
+  plugins.push(postcssWeappTailwindcssPostPlugin(options));
+  return plugins;
+}
+
+export {
+  pluginName,
+  vitePluginName,
+  WEAPP_TW_REQUIRED_NODE_VERSION,
+  postcssWeappTailwindcssPostPlugin,
+  postcssWeappTailwindcssPrePlugin,
+  getPlugins,
+  default2 as default,
+  default3 as default2
+};