weapp-tailwindcss 3.3.7 → 3.4.0-alpha.1

package/dist/chunk-LYLCSEZ7.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 _chunk33GCHXV2js = require('./chunk-33GCHXV2.js');
+
+
+
+var _chunkU2UGOG3Rjs = require('./chunk-U2UGOG3R.js');
+
+// src/bundlers/gulp/index.ts
+var _stream = require('stream'); var _stream2 = _interopRequireDefault(_stream);
+var _buffer = require('buffer');
+var debug = _chunkHBQASQKYjs.createDebug.call(void 0, );
+var Transform = _stream2.default.Transform;
+function createPlugins(options = {}) {
+  const opts = _chunk33GCHXV2js.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 _chunkU2UGOG3Rjs.__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;
+                }
+              },
+              () => _chunkU2UGOG3Rjs.__async.call(void 0, this, null, function* () {
+                const code = yield styleHandler(rawSource, _chunkU2UGOG3Rjs.__spreadValues.call(void 0, {
+                  isMainChunk: true
+                }, options2));
+                file.contents = _buffer.Buffer.from(code);
+                debug("css handle: %s", file.path);
+                return {
+                  key: file.path,
+                  source: code
+                };
+              })
+            );
+          }
+          callback(error, file);
+        });
+      }
+      // construct(callback) {
+      //   debug('transformWxss start')
+      //   callback()
+      // }
+    });
+  }
+  function transformJs(options2 = {}) {
+    return new Transform({
+      objectMode: true,
+      transform(file, encoding, callback) {
+        return _chunkU2UGOG3Rjs.__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;
+                }
+              },
+              () => _chunkU2UGOG3Rjs.__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 _chunkU2UGOG3Rjs.__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;
+                }
+              },
+              () => _chunkU2UGOG3Rjs.__async.call(void 0, this, null, function* () {
+                const code = yield templateHandler(rawSource, _chunkU2UGOG3Rjs.__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-NVFWRLOI.mjs

@@ -0,0 +1,27 @@
+import {
+  escape_exports
+} from "./chunk-VECXHWWG.mjs";
+
+// src/wxml/shared.ts
+function replaceWxml(original, options = {
+  keepEOL: false,
+  escapeMap: escape_exports.SimpleMappingChars2String
+}) {
+  const { keepEOL, escapeMap, mangleContext, ignoreHead } = options;
+  let res = original;
+  if (!keepEOL) {
+    res = res.replaceAll(/[\n\r]+/g, "");
+  }
+  if (mangleContext) {
+    res = mangleContext.wxmlHandler(res);
+  }
+  res = (0, escape_exports.escape)(res, {
+    map: escapeMap,
+    ignoreHead
+  });
+  return res;
+}
+
+export {
+  replaceWxml
+};

package/dist/chunk-ODCGCGWM.js

@@ -0,0 +1,533 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+var _chunk77FRX3XGjs = require('./chunk-77FRX3XG.js');
+
+// 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 = "16.6.0";
+
+// src/postcss/selectorParser.ts
+var _postcssselectorparser = require('postcss-selector-parser'); var _postcssselectorparser2 = _interopRequireDefault(_postcssselectorparser);
+function createRuleTransform(rule, options) {
+  const { escapeMap, mangleContext, cssSelectorReplacement, cssRemoveHoverPseudoClass } = options;
+  const transform = (selectors) => {
+    selectors.walk((selector) => {
+      if (selector.type === "universal" && cssSelectorReplacement && cssSelectorReplacement.universal) {
+        selector.value = _chunk77FRX3XGjs.composeIsPseudo.call(void 0, cssSelectorReplacement.universal);
+      }
+      if (cssRemoveHoverPseudoClass && selector.type === "selector") {
+        const node = selector.nodes.find((x) => x.type === "pseudo" && x.value === ":hover");
+        node && selector.remove();
+      }
+      if (selector.type === "pseudo" && selector.value === ":root" && cssSelectorReplacement && cssSelectorReplacement.root) {
+        selector.value = _chunk77FRX3XGjs.composeIsPseudo.call(void 0, cssSelectorReplacement.root);
+      }
+      if (selector.type === "class") {
+        selector.value = _chunk77FRX3XGjs.internalCssSelectorReplacer.call(void 0, selector.value, {
+          escapeMap,
+          mangleContext
+        });
+      }
+    });
+    if (selectors.length === 0) {
+      rule.remove();
+    }
+  };
+  return transform;
+}
+function getRuleTransformer(rule, options) {
+  return _postcssselectorparser2.default.call(void 0, 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;
+  _postcssselectorparser2.default.call(void 0, (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 = _postcssselectorparser2.default.call(void 0, (selectors) => {
+  selectors.walk((selector) => {
+    var _a, _b;
+    if (selector.type === "universal") {
+      (_a = selector.parent) == null ? void 0 : _a.remove();
+    }
+    if (selector.type === "pseudo" && selector.value === ":is") {
+      (_b = selector.parent) == null ? void 0 : _b.remove();
+    }
+  });
+});
+
+// src/postcss/mp.ts
+var _postcss = require('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 (0, _postcss.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 (0, _postcss.Rule)({
+    // selectors: ['::before', '::after'],
+    selector: "::before,::after"
+  });
+  pseudoVarRule.append(
+    new (0, _postcss.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 = _chunk77FRX3XGjs.composeIsPseudo.call(void 0, 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 (0, _postcss.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/post.ts
+var postcssWeappTailwindcssPostPlugin = (options = {
+  isMainChunk: true
+}) => {
+  const { customRuleCallback, isMainChunk, ctx } = options;
+  const p = {
+    postcssPlugin
+  };
+  if (isMainChunk) {
+    p.OnceExit = (root) => {
+      root.walkRules((rule) => {
+        if (ctx) {
+          if (ctx.isVariablesScope(rule)) {
+            fallbackRemove.transformSync(rule, {
+              updateSelector: true,
+              lossless: false
+            });
+          }
+        } else if (testIfVariablesScope(rule)) {
+          fallbackRemove.transformSync(rule, {
+            updateSelector: true,
+            lossless: false
+          });
+        }
+      });
+    };
+  }
+  if (typeof customRuleCallback === "function") {
+    p.Rule = (rule) => {
+      customRuleCallback(rule, options);
+    };
+  }
+  return p;
+};
+postcssWeappTailwindcssPostPlugin.postcss = true;
+
+// src/postcss/plugins/index.ts
+var _postcssispseudoclass = require('@csstools/postcss-is-pseudo-class'); var _postcssispseudoclass2 = _interopRequireDefault(_postcssispseudoclass);
+var _postcssremtoresponsivepixel = require('postcss-rem-to-responsive-pixel'); var _postcssremtoresponsivepixel2 = _interopRequireDefault(_postcssremtoresponsivepixel);
+
+// 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
+
+
+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),
+    _postcssispseudoclass2.default.call(void 0, {
+      specificityMatchingName: "weapp-tw-ig"
+    })
+  ];
+  if (options.rem2rpx) {
+    plugins.push(
+      _postcssremtoresponsivepixel2.default.call(void 0, 
+        typeof options.rem2rpx === "object" ? options.rem2rpx : {
+          rootValue: 32,
+          propList: ["*"],
+          transformUnit: "rpx"
+        }
+      )
+    );
+  }
+  plugins.push(postcssWeappTailwindcssPostPlugin(options));
+  return plugins;
+}
+
+
+
+
+
+
+
+
+
+
+exports.pluginName = pluginName; exports.vitePluginName = vitePluginName; exports.WEAPP_TW_REQUIRED_NODE_VERSION = WEAPP_TW_REQUIRED_NODE_VERSION; exports.postcssWeappTailwindcssPrePlugin = postcssWeappTailwindcssPrePlugin; exports.postcssWeappTailwindcssPostPlugin = postcssWeappTailwindcssPostPlugin; exports.getPlugins = getPlugins; exports.default = _postcssispseudoclass2.default; exports.default2 = _postcssremtoresponsivepixel2.default;