weapp-tailwindcss 4.3.2 → 4.4.0-alpha.0

package/dist/chunk-2F7HOQQY.mjs

@@ -0,0 +1,8 @@
+// src/bundlers/webpack/BaseUnifiedPlugin/shared.ts
+function getCacheKey(filename) {
+  return filename;
+}
+
+export {
+  getCacheKey
+};

package/dist/chunk-2NRTWL47.js

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// 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((_nullishCoalesce(prefix, () => ( ""))) + formatter, ...args);
+  }
+  return debug;
+}
+
+// src/bundlers/shared/cache.ts
+async function processCachedTask({
+  cache,
+  cacheKey,
+  hashKey = cacheKey,
+  rawSource,
+  readCache,
+  applyResult,
+  transform,
+  onCacheHit
+}) {
+  let cacheHit = false;
+  const result = await cache.process({
+    key: cacheKey,
+    hashKey,
+    rawSource,
+    resolveCache: readCache,
+    async onCacheHit(value) {
+      cacheHit = true;
+      await applyResult(value);
+      _optionalChain([onCacheHit, 'optionalCall', _ => _()]);
+    },
+    transform
+  });
+  if (!cacheHit) {
+    await applyResult(result);
+  }
+}
+
+
+
+
+exports.createDebug = createDebug; exports.processCachedTask = processCachedTask;

package/dist/{chunk-YNMM5ZP5.mjs → chunk-3MSGCIVH.mjs}

@@ -1,19 +1,20 @@
 import {
-  createDebug
-} from "./chunk-3AUX4FGE.mjs";
+  createDebug,
+  processCachedTask
+} from "./chunk-H4JTYYOI.mjs";
 import {
   vitePluginName
 } from "./chunk-CMUA5KCO.mjs";
 import {
   generateCode,
   getCompilerContext
-} from "./chunk-DGVVFKNF.mjs";
+} from "./chunk-WCIVXE2D.mjs";
 import {
   replaceWxml
 } from "./chunk-Q67IXIAH.mjs";
 import {
   getGroupedEntries
-} from "./chunk-JXBLHLFR.mjs";
+} from "./chunk-ZNKIYZRQ.mjs";
 
 // src/bundlers/vite/index.ts
 import postcssHtmlTransform from "@weapp-tailwindcss/postcss/html-transform";
@@ -24,10 +25,32 @@ import MagicString from "magic-string";
 import { parse } from "vue/compiler-sfc";
 function traverse(node, visitor) {
   visitor(node);
-  if (node.children) {
-    node.children.forEach((child) => traverse(child, visitor));
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      if (child && typeof child === "object" && "type" in child) {
+        traverse(child, visitor);
+      }
+    }
   }
 }
+function createClassAttributeUpdater(ms) {
+  return (prop) => {
+    if (prop.value) {
+      ms.update(prop.value.loc.start.offset + 1, prop.value.loc.end.offset - 1, replaceWxml(prop.value.content));
+    }
+  };
+}
+function createClassDirectiveUpdater(ms, jsHandler, runtimeSet) {
+  return (prop) => {
+    if (prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "class" && prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION) {
+      const generated = generateCode(prop.exp.content, {
+        jsHandler,
+        runtimeSet
+      });
+      ms.update(prop.exp.loc.start.offset, prop.exp.loc.end.offset, generated);
+    }
+  };
+}
 var defaultCreateJsHandlerOptions = {
   babelParserOptions: {
     plugins: [
@@ -42,27 +65,21 @@ function transformUVue(code, id, jsHandler, runtimeSet) {
   const ms = new MagicString(code);
   const { descriptor, errors } = parse(code);
   if (errors.length === 0) {
-    if (descriptor.template) {
-      let extractClassNames2 = function(node) {
-        if (node.type === NodeTypes.ELEMENT) {
-          node.props.forEach((prop) => {
-            if (prop.type === NodeTypes.ATTRIBUTE && prop.name === "class" && prop.value) {
-              ms.update(prop.value.loc.start.offset + 1, prop.value.loc.end.offset - 1, replaceWxml(prop.value.content));
-            }
-            if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "class") {
-              if (prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION) {
-                const code2 = generateCode(prop.exp.content, {
-                  jsHandler,
-                  runtimeSet
-                });
-                ms.update(prop.exp.loc.start.offset, prop.exp.loc.end.offset, code2);
-              }
-            }
-          });
+    if (descriptor.template?.ast) {
+      const updateStaticClass = createClassAttributeUpdater(ms);
+      const updateDynamicClass = createClassDirectiveUpdater(ms, jsHandler, runtimeSet);
+      traverse(descriptor.template.ast, (node) => {
+        if (node.type !== NodeTypes.ELEMENT) {
+          return;
         }
-      };
-      var extractClassNames = extractClassNames2;
-      traverse(descriptor.template.ast, extractClassNames2);
+        for (const prop of node.props) {
+          if (prop.type === NodeTypes.ATTRIBUTE && prop.name === "class") {
+            updateStaticClass(prop);
+          } else if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind") {
+            updateDynamicClass(prop);
+          }
+        }
+      });
     }
     if (descriptor.script) {
       const { code: code2 } = jsHandler(descriptor.script.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
@@ -172,10 +189,6 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   let runtimeSet;
   onLoad();
   const plugins = [
-    // {
-    //   name: `${vitePluginName}:pre`,
-    //   enforce: 'pre',
-    // },
     {
       name: `${vitePluginName}:post`,
       enforce: "post",
@@ -199,134 +212,114 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
         runtimeSet = await twPatcher.getClassSet();
         setMangleRuntimeSet(runtimeSet);
         debug("get runtimeSet, class count: %d", runtimeSet.size);
-        const promises = [];
+        const tasks = [];
         if (Array.isArray(groupedEntries.html)) {
-          for (const element of groupedEntries.html) {
-            const [file, originalSource] = element;
-            const oldVal = originalSource.source.toString();
-            const hash = cache.computeHash(oldVal);
-            cache.calcHashValueChanged(file, hash);
-            promises.push(
-              cache.process(
-                file,
-                () => {
-                  const source = cache.get(file);
-                  if (source) {
-                    originalSource.source = source;
-                    debug("html cache hit: %s", file);
-                  } else {
-                    return false;
-                  }
+          for (const [file, originalSource] of groupedEntries.html) {
+            const rawSource = originalSource.source.toString();
+            tasks.push(
+              processCachedTask({
+                cache,
+                cacheKey: file,
+                rawSource,
+                applyResult(source) {
+                  originalSource.source = source;
+                },
+                onCacheHit() {
+                  debug("html cache hit: %s", file);
                 },
-                async () => {
-                  originalSource.source = await templateHandler(oldVal, {
+                async transform() {
+                  const transformed = await templateHandler(rawSource, {
                     runtimeSet
                   });
-                  onUpdate(file, oldVal, originalSource.source);
+                  onUpdate(file, rawSource, transformed);
                   debug("html handle: %s", file);
                   return {
-                    key: file,
-                    source: originalSource.source
+                    result: transformed
                   };
                 }
-              )
+              })
             );
           }
         }
         if (Array.isArray(groupedEntries.js)) {
-          for (const element of groupedEntries.js.filter((x) => x[1].type === "chunk")) {
-            const [file, originalSource] = element;
-            const rawSource = originalSource.code;
-            const hash = cache.computeHash(rawSource);
-            cache.calcHashValueChanged(file, hash);
-            promises.push(
-              cache.process(
-                file,
-                () => {
-                  const source = cache.get(file);
-                  if (source) {
+          for (const [file, originalSource] of groupedEntries.js) {
+            if (originalSource.type === "chunk") {
+              const rawSource = originalSource.code;
+              tasks.push(
+                processCachedTask({
+                  cache,
+                  cacheKey: file,
+                  rawSource,
+                  applyResult(source) {
                     originalSource.code = source;
+                  },
+                  onCacheHit() {
                     debug("js cache hit: %s", file);
-                  } else {
-                    return false;
-                  }
-                },
-                async () => {
-                  const { code } = await jsHandler(rawSource, runtimeSet, {
-                    // generateMap: hasSourceMap,
-                  });
-                  originalSource.code = code;
-                  onUpdate(file, rawSource, code);
-                  debug("js handle: %s", file);
-                  return {
-                    key: file,
-                    source: code
-                  };
-                }
-              )
-            );
-          }
-          if (uniAppX) {
-            for (const element of groupedEntries.js.filter((x) => x[1].type === "asset")) {
-              const [file, originalSource] = element;
-              const rawSource = originalSource.source.toString();
-              const hash = cache.computeHash(rawSource);
-              cache.calcHashValueChanged(file, hash);
-              promises.push(
-                cache.process(
-                  file,
-                  () => {
-                    const source = cache.get(file);
-                    if (source) {
-                      originalSource.source = source;
-                      debug("js cache hit: %s", file);
-                    } else {
-                      return false;
-                    }
                   },
-                  async () => {
-                    const { code } = await jsHandler(rawSource, runtimeSet, {
-                      // generateMap: hasSourceMap,
-                      uniAppX,
-                      babelParserOptions: {
-                        plugins: [
-                          "typescript"
-                        ],
-                        sourceType: "unambiguous"
-                      }
-                    });
-                    originalSource.source = code;
+                  async transform() {
+                    const { code } = await jsHandler(rawSource, runtimeSet);
                     onUpdate(file, rawSource, code);
                     debug("js handle: %s", file);
                     return {
-                      key: file,
-                      source: code
+                      result: code
                     };
                   }
-                )
+                })
               );
             }
           }
+          if (uniAppX) {
+            for (const [file, originalSource] of groupedEntries.js) {
+              if (originalSource.type === "asset") {
+                const rawSource = originalSource.source.toString();
+                tasks.push(
+                  processCachedTask({
+                    cache,
+                    cacheKey: file,
+                    rawSource,
+                    applyResult(source) {
+                      originalSource.source = source;
+                    },
+                    onCacheHit() {
+                      debug("js cache hit: %s", file);
+                    },
+                    async transform() {
+                      const { code } = await jsHandler(rawSource, runtimeSet, {
+                        uniAppX,
+                        babelParserOptions: {
+                          plugins: [
+                            "typescript"
+                          ],
+                          sourceType: "unambiguous"
+                        }
+                      });
+                      onUpdate(file, rawSource, code);
+                      debug("js handle: %s", file);
+                      return {
+                        result: code
+                      };
+                    }
+                  })
+                );
+              }
+            }
+          }
         }
         if (Array.isArray(groupedEntries.css)) {
-          for (const element of groupedEntries.css) {
-            const [file, originalSource] = element;
+          for (const [file, originalSource] of groupedEntries.css) {
             const rawSource = originalSource.source.toString();
-            const hash = cache.computeHash(rawSource);
-            cache.calcHashValueChanged(file, hash);
-            promises.push(
-              cache.process(
-                file,
-                () => {
-                  const source = cache.get(file);
-                  if (source) {
-                    originalSource.source = source;
-                    debug("css cache hit: %s", file);
-                  } else {
-                    return false;
-                  }
+            tasks.push(
+              processCachedTask({
+                cache,
+                cacheKey: file,
+                rawSource,
+                applyResult(source) {
+                  originalSource.source = source;
+                },
+                onCacheHit() {
+                  debug("css cache hit: %s", file);
                 },
-                async () => {
+                async transform() {
                   const { css } = await styleHandler(rawSource, {
                     isMainChunk: mainCssChunkMatcher(originalSource.fileName, appType),
                     postcssOptions: {
@@ -336,19 +329,17 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
                     },
                     majorVersion: twPatcher.majorVersion
                   });
-                  originalSource.source = css;
                   onUpdate(file, rawSource, css);
                   debug("css handle: %s", file);
                   return {
-                    key: file,
-                    source: css
+                    result: css
                   };
                 }
-              )
+              })
             );
           }
         }
-        await Promise.all(promises);
+        await Promise.all(tasks);
         onEnd();
         debug("end");
       }
@@ -375,8 +366,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
                       // postcss may return virtual files
                       // we cannot obtain content of them, so this needs to be enabled
                       sourcesContent: true
-                      // when "prev: preprocessorMap", the result map may include duplicate filename in `postcssResult.map.sources`
-                      // prev: preprocessorMap,
+                      // when a previous preprocessor map is provided, duplicates may appear in `postcssResult.map.sources`
                     }
                   }
                 }

package/dist/chunk-6GP37C26.js

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/bundlers/webpack/BaseUnifiedPlugin/shared.ts
+function getCacheKey(filename) {
+  return filename;
+}
+
+
+
+exports.getCacheKey = getCacheKey;