weapp-tailwindcss 3.7.0 → 3.8.0-alpha.1

package/dist/chunk-NLFQ7XRK.mjs

@@ -0,0 +1,152 @@
+import {
+  createDebug
+} from "./chunk-75EWCRQW.mjs";
+import {
+  getOptions
+} from "./chunk-MWTUP5KG.mjs";
+import {
+  __async,
+  __spreadValues
+} from "./chunk-AXBFBHS2.mjs";
+
+// src/bundlers/gulp/index.ts
+import { Buffer } from "node:buffer";
+import stream from "node:stream";
+var debug = createDebug();
+var Transform = stream.Transform;
+function createPlugins(options = {}) {
+  const opts = getOptions(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 __async(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.from(source);
+                  debug("css cache hit: %s", file.path);
+                } else {
+                  return false;
+                }
+              },
+              () => __async(this, null, function* () {
+                const { css } = yield styleHandler(rawSource, __spreadValues({
+                  isMainChunk: true
+                }, options2));
+                file.contents = 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 __async(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.from(source);
+                  debug("js cache hit: %s", file.path);
+                } else {
+                  return false;
+                }
+              },
+              () => __async(this, null, function* () {
+                const { code } = yield jsHandler(rawSource, runtimeSet, options2);
+                file.contents = 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 __async(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.from(source);
+                  debug("html cache hit: %s", file.path);
+                } else {
+                  return false;
+                }
+              },
+              () => __async(this, null, function* () {
+                const code = yield templateHandler(rawSource, __spreadValues({
+                  runtimeSet
+                }, options2));
+                file.contents = Buffer.from(code);
+                debug("html handle: %s", file.path);
+                return {
+                  key: file.path,
+                  source: code
+                };
+              })
+            );
+          }
+          callback(error, file);
+        });
+      }
+    });
+  }
+  return {
+    transformWxss,
+    transformWxml,
+    transformJs
+  };
+}
+
+export {
+  createPlugins
+};

package/dist/chunk-QEEWOML6.mjs

@@ -0,0 +1,216 @@
+import {
+  createDebug
+} from "./chunk-75EWCRQW.mjs";
+import {
+  getOptions
+} from "./chunk-MWTUP5KG.mjs";
+import {
+  getGroupedEntries,
+  removeExt
+} from "./chunk-MUJ65IQ3.mjs";
+import {
+  pluginName
+} from "./chunk-KE7J6XFD.mjs";
+import {
+  __async
+} from "./chunk-AXBFBHS2.mjs";
+
+// src/bundlers/webpack/BaseUnifiedPlugin/v5.ts
+import fs from "node:fs";
+import path from "node:path";
+var debug = createDebug();
+var UnifiedWebpackPluginV5 = class {
+  constructor(options = {}) {
+    this.options = getOptions(options);
+    this.appType = this.options.appType;
+  }
+  apply(compiler) {
+    const {
+      mainCssChunkMatcher,
+      disabled,
+      onLoad,
+      onUpdate,
+      onEnd,
+      onStart,
+      styleHandler,
+      patch,
+      templateHandler,
+      jsHandler,
+      setMangleRuntimeSet,
+      runtimeLoaderPath,
+      cache,
+      twPatcher
+    } = this.options;
+    if (disabled) {
+      return;
+    }
+    patch == null ? void 0 : patch();
+    const { Compilation, sources, NormalModule } = compiler.webpack;
+    const { ConcatSource, RawSource } = sources;
+    function getClassSet() {
+      return twPatcher.getClassSet();
+    }
+    onLoad();
+    const loader = runtimeLoaderPath != null ? runtimeLoaderPath : path.resolve(__dirname, "./weapp-tw-runtime-loader.js");
+    const isExisted = fs.existsSync(loader);
+    const WeappTwRuntimeAopLoader = {
+      loader,
+      options: {
+        getClassSet
+      },
+      ident: null,
+      type: null
+    };
+    compiler.hooks.compilation.tap(pluginName, (compilation) => {
+      NormalModule.getCompilationHooks(compilation).loader.tap(pluginName, (_loaderContext, module) => {
+        if (isExisted) {
+          const idx = module.loaders.findIndex((x) => x.loader.includes("postcss-loader"));
+          if (idx > -1) {
+            module.loaders.unshift(WeappTwRuntimeAopLoader);
+          }
+        }
+      });
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: pluginName,
+          stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+        },
+        (assets) => __async(this, null, function* () {
+          onStart();
+          debug("start");
+          for (const chunk of compilation.chunks) {
+            if (chunk.id && chunk.hash) {
+              cache.calcHashValueChanged(chunk.id, chunk.hash);
+            }
+          }
+          const entries = Object.entries(assets);
+          const groupedEntries = getGroupedEntries(entries, this.options);
+          const runtimeSet = getClassSet();
+          setMangleRuntimeSet(runtimeSet);
+          debug("get runtimeSet, class count: %d", runtimeSet.size);
+          if (Array.isArray(groupedEntries.html)) {
+            let noCachedCount = 0;
+            for (let i = 0; i < groupedEntries.html.length; i++) {
+              const [file, originalSource] = groupedEntries.html[i];
+              const rawSource = originalSource.source().toString();
+              const hash = cache.computeHash(rawSource);
+              const cacheKey = file;
+              cache.calcHashValueChanged(cacheKey, hash);
+              yield cache.process(
+                cacheKey,
+                () => {
+                  const source = cache.get(cacheKey);
+                  if (source) {
+                    compilation.updateAsset(file, source);
+                    debug("html cache hit: %s", file);
+                  } else {
+                    return false;
+                  }
+                },
+                () => __async(this, null, function* () {
+                  const wxml = yield templateHandler(rawSource, {
+                    runtimeSet
+                  });
+                  const source = new ConcatSource(wxml);
+                  compilation.updateAsset(file, source);
+                  onUpdate(file, rawSource, wxml);
+                  debug("html handle: %s", file);
+                  noCachedCount++;
+                  return {
+                    key: cacheKey,
+                    source
+                  };
+                })
+              );
+            }
+            debug("html handle finish, total: %d, no-cached: %d", groupedEntries.html.length, noCachedCount);
+          }
+          if (Array.isArray(groupedEntries.js)) {
+            let noCachedCount = 0;
+            for (let i = 0; i < groupedEntries.js.length; i++) {
+              const [file, originalSource] = groupedEntries.js[i];
+              const cacheKey = removeExt(file);
+              yield cache.process(
+                cacheKey,
+                () => {
+                  const source = cache.get(cacheKey);
+                  if (source) {
+                    compilation.updateAsset(file, source);
+                    debug("js cache hit: %s", file);
+                  } else {
+                    return false;
+                  }
+                },
+                () => __async(this, null, function* () {
+                  const rawSource = originalSource.source().toString();
+                  const mapFilename = `${file}.map`;
+                  const hasMap = Boolean(assets[mapFilename]);
+                  const { code, map } = yield jsHandler(rawSource, runtimeSet, {
+                    generateMap: hasMap
+                  });
+                  const source = new ConcatSource(code);
+                  compilation.updateAsset(file, source);
+                  onUpdate(file, rawSource, code);
+                  debug("js handle: %s", file);
+                  noCachedCount++;
+                  if (hasMap && map) {
+                    const source2 = new RawSource(map.toString());
+                    compilation.updateAsset(mapFilename, source2);
+                  }
+                  return {
+                    key: cacheKey,
+                    source
+                  };
+                })
+              );
+            }
+            debug("js handle finish, total: %d, no-cached: %d", groupedEntries.js.length, noCachedCount);
+          }
+          if (Array.isArray(groupedEntries.css)) {
+            let noCachedCount = 0;
+            for (let i = 0; i < groupedEntries.css.length; i++) {
+              const [file, originalSource] = groupedEntries.css[i];
+              const rawSource = originalSource.source().toString();
+              const hash = cache.computeHash(rawSource);
+              const cacheKey = file;
+              cache.calcHashValueChanged(cacheKey, hash);
+              yield cache.process(
+                cacheKey,
+                () => {
+                  const source = cache.get(cacheKey);
+                  if (source) {
+                    compilation.updateAsset(file, source);
+                    debug("css cache hit: %s", file);
+                  } else {
+                    return false;
+                  }
+                },
+                () => __async(this, null, function* () {
+                  const { css } = yield styleHandler(rawSource, {
+                    isMainChunk: mainCssChunkMatcher(file, this.appType)
+                  });
+                  const source = new ConcatSource(css);
+                  compilation.updateAsset(file, source);
+                  onUpdate(file, rawSource, css);
+                  debug("css handle: %s", file);
+                  noCachedCount++;
+                  return {
+                    key: cacheKey,
+                    source
+                  };
+                })
+              );
+            }
+            debug("css handle finish, total: %d, no-cached: %d", groupedEntries.css.length, noCachedCount);
+          }
+          debug("end");
+          onEnd();
+        })
+      );
+    });
+  }
+};
+
+export {
+  UnifiedWebpackPluginV5
+};

package/dist/chunk-RFNUATFD.js

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/wxml/shared.ts
+var _escape = require('@weapp-core/escape');
+function replaceWxml(original, options = {
+  keepEOL: false,
+  escapeMap: _escape.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 = _escape.escape.call(void 0, res, {
+    map: escapeMap,
+    ignoreHead
+  });
+  return res;
+}
+
+
+
+exports.replaceWxml = replaceWxml;

package/dist/chunk-U7O2XXYR.mjs

@@ -0,0 +1,24 @@
+// src/wxml/shared.ts
+import { escape, SimpleMappingChars2String } from "@weapp-core/escape";
+function replaceWxml(original, options = {
+  keepEOL: false,
+  escapeMap: 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 = escape(res, {
+    map: escapeMap,
+    ignoreHead
+  });
+  return res;
+}
+
+export {
+  replaceWxml
+};

package/dist/chunk-VKSQ6BRD.mjs

@@ -0,0 +1,27 @@
+// src/postcss/shared.ts
+import { escape, SimpleMappingChars2String } from "@weapp-core/escape";
+function internalCssSelectorReplacer(selectors, options = {
+  escapeMap: SimpleMappingChars2String
+}) {
+  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("");
+}
+
+export {
+  internalCssSelectorReplacer,
+  composeIsPseudo
+};

package/dist/chunk-XSZXPWWL.js

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/postcss/shared.ts
+var _escape = require('@weapp-core/escape');
+function internalCssSelectorReplacer(selectors, options = {
+  escapeMap: _escape.SimpleMappingChars2String
+}) {
+  const { mangleContext, escapeMap } = options;
+  if (mangleContext) {
+    selectors = mangleContext.cssHandler(selectors);
+  }
+  return _escape.escape.call(void 0, selectors, {
+    map: escapeMap
+  });
+}
+function composeIsPseudo(strs) {
+  if (typeof strs === "string") {
+    return strs;
+  }
+  if (strs.length > 1) {
+    return `:is(${strs.join(",")})`;
+  }
+  return strs.join("");
+}
+
+
+
+
+exports.internalCssSelectorReplacer = internalCssSelectorReplacer; exports.composeIsPseudo = composeIsPseudo;

package/dist/chunk-YSEHQ3FF.js

@@ -0,0 +1,173 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkHBQASQKYjs = require('./chunk-HBQASQKY.js');
+
+
+var _chunkLWRZXI5Tjs = require('./chunk-LWRZXI5T.js');
+
+
+var _chunk35CYTBPMjs = require('./chunk-35CYTBPM.js');
+
+
+var _chunkLQN2VTMUjs = require('./chunk-LQN2VTMU.js');
+
+
+var _chunk6FNC3XMIjs = require('./chunk-6FNC3XMI.js');
+
+// src/bundlers/vite/index.ts
+var debug = _chunkHBQASQKYjs.createDebug.call(void 0, );
+function UnifiedViteWeappTailwindcssPlugin(options = {}) {
+  const opts = _chunkLWRZXI5Tjs.getOptions.call(void 0, options);
+  const {
+    disabled,
+    onEnd,
+    onLoad,
+    onStart,
+    onUpdate,
+    templateHandler,
+    styleHandler,
+    patch,
+    jsHandler,
+    mainCssChunkMatcher,
+    appType,
+    setMangleRuntimeSet,
+    cache,
+    twPatcher
+  } = opts;
+  if (disabled) {
+    return;
+  }
+  patch == null ? void 0 : patch();
+  onLoad();
+  return {
+    name: _chunkLQN2VTMUjs.vitePluginName,
+    enforce: "post",
+    generateBundle(_opt, bundle) {
+      return _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+        debug("start");
+        onStart();
+        const entries = Object.entries(bundle);
+        const groupedEntries = _chunk35CYTBPMjs.getGroupedEntries.call(void 0, entries, opts);
+        const runtimeSet = twPatcher.getClassSet();
+        setMangleRuntimeSet(runtimeSet);
+        debug("get runtimeSet, class count: %d", runtimeSet.size);
+        if (Array.isArray(groupedEntries.html)) {
+          let noCachedCount = 0;
+          for (let i = 0; i < groupedEntries.html.length; i++) {
+            const [file, originalSource] = groupedEntries.html[i];
+            const oldVal = originalSource.source.toString();
+            const hash = cache.computeHash(oldVal);
+            cache.calcHashValueChanged(file, hash);
+            yield cache.process(
+              file,
+              () => {
+                const source = cache.get(file);
+                if (source) {
+                  originalSource.source = source;
+                  debug("html cache hit: %s", file);
+                } else {
+                  return false;
+                }
+              },
+              () => _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+                originalSource.source = yield templateHandler(oldVal, {
+                  runtimeSet
+                });
+                onUpdate(file, oldVal, originalSource.source);
+                debug("html handle: %s", file);
+                noCachedCount++;
+                return {
+                  key: file,
+                  source: originalSource.source
+                };
+              })
+            );
+          }
+          debug("html handle finish, total: %d, no-cached: %d", groupedEntries.html.length, noCachedCount);
+        }
+        if (Array.isArray(groupedEntries.js)) {
+          let noCachedCount = 0;
+          for (let i = 0; i < groupedEntries.js.length; i++) {
+            const [file, originalSource] = groupedEntries.js[i];
+            const rawSource = originalSource.code;
+            const hash = cache.computeHash(rawSource);
+            cache.calcHashValueChanged(file, hash);
+            yield cache.process(
+              file,
+              () => {
+                const source = cache.get(file);
+                if (source) {
+                  originalSource.code = source;
+                  debug("js cache hit: %s", file);
+                } else {
+                  return false;
+                }
+              },
+              () => _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+                const mapFilename = `${file}.map`;
+                const hasMap = Boolean(bundle[mapFilename]);
+                const { code, map } = yield jsHandler(rawSource, runtimeSet, {
+                  generateMap: hasMap
+                });
+                originalSource.code = code;
+                onUpdate(file, rawSource, code);
+                debug("js handle: %s", file);
+                noCachedCount++;
+                if (hasMap && map) {
+                  ;
+                  bundle[mapFilename].source = map.toString();
+                }
+                return {
+                  key: file,
+                  source: code
+                };
+              })
+            );
+          }
+          debug("js handle finish, total: %d, no-cached: %d", groupedEntries.js.length, noCachedCount);
+        }
+        if (Array.isArray(groupedEntries.css)) {
+          let noCachedCount = 0;
+          for (let i = 0; i < groupedEntries.css.length; i++) {
+            const [file, originalSource] = groupedEntries.css[i];
+            const rawSource = originalSource.source.toString();
+            const hash = cache.computeHash(rawSource);
+            cache.calcHashValueChanged(file, hash);
+            yield cache.process(
+              file,
+              () => {
+                const source = cache.get(file);
+                if (source) {
+                  originalSource.source = source;
+                  debug("css cache hit: %s", file);
+                } else {
+                  return false;
+                }
+              },
+              () => _chunk6FNC3XMIjs.__async.call(void 0, this, null, function* () {
+                const { css } = yield styleHandler(rawSource, {
+                  isMainChunk: mainCssChunkMatcher(originalSource.fileName, appType)
+                });
+                originalSource.source = css;
+                onUpdate(file, rawSource, css);
+                debug("css handle: %s", file);
+                noCachedCount++;
+                return {
+                  key: file,
+                  source: css
+                };
+              })
+            );
+          }
+          debug("css handle finish, total: %d, no-cached: %d", groupedEntries.css.length, noCachedCount);
+        }
+        onEnd();
+        debug("end");
+      });
+    }
+  };
+}
+
+
+
+exports.UnifiedViteWeappTailwindcssPlugin = UnifiedViteWeappTailwindcssPlugin;