weapp-tailwindcss 4.9.2-alpha.2 → 4.9.3

package/dist/chunk-PU5CC4ZI.mjs

@@ -0,0 +1,444 @@
+import {
+  applyTailwindcssCssImportRewrite,
+  createLoaderAnchorFinders,
+  ensureMpxTailwindcssAliases,
+  getCacheKey,
+  hasLoaderEntry,
+  injectMpxCssRewritePreRules,
+  isCssLikeModuleResource,
+  isMpx,
+  patchMpxLoaderResolve,
+  setupMpxTailwindcssRedirect
+} from "./chunk-WH65CIYG.mjs";
+import {
+  pushConcurrentTaskFactories,
+  resolveDisabledOptions,
+  resolveOutputSpecifier,
+  resolvePackageDir,
+  toAbsoluteOutputPath
+} from "./chunk-F2CKKG6Q.mjs";
+import {
+  processCachedTask
+} from "./chunk-RRHPTTCP.mjs";
+import {
+  setupPatchRecorder
+} from "./chunk-ZL22KEHH.mjs";
+import {
+  collectRuntimeClassSet,
+  createDebug,
+  getCompilerContext,
+  pluginName,
+  refreshTailwindRuntimeState
+} from "./chunk-IW3B6ZJD.mjs";
+import {
+  getGroupedEntries
+} from "./chunk-OOHJLO5M.mjs";
+import {
+  __dirname
+} from "./chunk-SPH6SCTM.mjs";
+
+// src/bundlers/webpack/BaseUnifiedPlugin/v5.ts
+import process3 from "process";
+
+// src/bundlers/webpack/BaseUnifiedPlugin/v5-assets.ts
+import path from "path";
+import process from "process";
+function setupWebpackV5ProcessAssetsHook(options) {
+  const {
+    compiler,
+    options: compilerOptions,
+    appType,
+    runtimeState,
+    refreshRuntimeState,
+    debug: debug2
+  } = options;
+  const { Compilation, sources } = compiler.webpack;
+  const { ConcatSource } = sources;
+  compiler.hooks.compilation.tap(pluginName, (compilation) => {
+    compilation.hooks.processAssets.tapPromise(
+      {
+        name: pluginName,
+        stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+      },
+      async (assets) => {
+        compilerOptions.onStart();
+        debug2("start");
+        await runtimeState.patchPromise;
+        for (const chunk of compilation.chunks) {
+          if (chunk.id && chunk.hash) {
+            compilerOptions.cache.calcHashValueChanged(chunk.id, chunk.hash);
+          }
+        }
+        const entries = Object.entries(assets);
+        const compilerOutputPath = compilation.compiler?.outputPath ?? compiler.outputPath;
+        const outputDir = compilerOutputPath ? path.resolve(compilerOutputPath) : compilation.outputOptions?.path ?? process.cwd();
+        const jsAssets = /* @__PURE__ */ new Map();
+        for (const [file] of entries) {
+          if (compilerOptions.jsMatcher(file) || compilerOptions.wxsMatcher(file)) {
+            const absolute = toAbsoluteOutputPath(file, outputDir);
+            jsAssets.set(absolute, file);
+          }
+        }
+        const moduleGraphOptions = {
+          resolve(specifier, importer) {
+            return resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => jsAssets.has(candidate));
+          },
+          load: (id) => {
+            const assetName = jsAssets.get(id);
+            if (!assetName) {
+              return void 0;
+            }
+            const asset = compilation.getAsset(assetName);
+            if (!asset) {
+              return void 0;
+            }
+            const source = asset.source.source();
+            return typeof source === "string" ? source : source.toString();
+          },
+          filter(id) {
+            return jsAssets.has(id);
+          }
+        };
+        const applyLinkedResults = (linked) => {
+          if (!linked) {
+            return;
+          }
+          for (const [id, { code }] of Object.entries(linked)) {
+            const assetName = jsAssets.get(id);
+            if (!assetName) {
+              continue;
+            }
+            const asset = compilation.getAsset(assetName);
+            if (!asset) {
+              continue;
+            }
+            const previousSource = asset.source.source();
+            const previous = typeof previousSource === "string" ? previousSource : previousSource.toString();
+            if (previous === code) {
+              continue;
+            }
+            const source = new ConcatSource(code);
+            compilation.updateAsset(assetName, source);
+            compilerOptions.onUpdate(assetName, previous, code);
+            debug2("js linked handle: %s", assetName);
+          }
+        };
+        const groupedEntries = getGroupedEntries(entries, compilerOptions);
+        await refreshRuntimeState(true);
+        await runtimeState.patchPromise;
+        const runtimeSet = await collectRuntimeClassSet(runtimeState.twPatcher, { force: true, skipRefresh: true });
+        debug2("get runtimeSet, class count: %d", runtimeSet.size);
+        const tasks = [];
+        if (Array.isArray(groupedEntries.html)) {
+          for (const element of groupedEntries.html) {
+            const [file, originalSource] = element;
+            const rawSource = originalSource.source().toString();
+            const cacheKey = file;
+            tasks.push(
+              processCachedTask({
+                cache: compilerOptions.cache,
+                cacheKey,
+                rawSource,
+                applyResult(source) {
+                  compilation.updateAsset(file, source);
+                },
+                onCacheHit() {
+                  debug2("html cache hit: %s", file);
+                },
+                transform: async () => {
+                  const wxml = await compilerOptions.templateHandler(rawSource, {
+                    runtimeSet
+                  });
+                  const source = new ConcatSource(wxml);
+                  compilerOptions.onUpdate(file, rawSource, wxml);
+                  debug2("html handle: %s", file);
+                  return {
+                    result: source
+                  };
+                }
+              })
+            );
+          }
+        }
+        const jsTaskFactories = [];
+        if (Array.isArray(groupedEntries.js)) {
+          for (const [file] of groupedEntries.js) {
+            const cacheKey = getCacheKey(file);
+            const asset = compilation.getAsset(file);
+            if (!asset) {
+              continue;
+            }
+            const absoluteFile = toAbsoluteOutputPath(file, outputDir);
+            const initialSource = asset.source.source();
+            const initialRawSource = typeof initialSource === "string" ? initialSource : initialSource.toString();
+            jsTaskFactories.push(async () => {
+              await processCachedTask({
+                cache: compilerOptions.cache,
+                cacheKey,
+                rawSource: initialRawSource,
+                applyResult(source) {
+                  compilation.updateAsset(file, source);
+                },
+                onCacheHit() {
+                  debug2("js cache hit: %s", file);
+                },
+                transform: async () => {
+                  const currentAsset = compilation.getAsset(file);
+                  const currentSourceValue = currentAsset?.source.source();
+                  const currentSource = typeof currentSourceValue === "string" ? currentSourceValue : currentSourceValue?.toString() ?? "";
+                  const { code, linked } = await compilerOptions.jsHandler(currentSource, runtimeSet, {
+                    filename: absoluteFile,
+                    moduleGraph: moduleGraphOptions,
+                    babelParserOptions: {
+                      sourceFilename: absoluteFile
+                    }
+                  });
+                  const source = new ConcatSource(code);
+                  compilerOptions.onUpdate(file, currentSource, code);
+                  debug2("js handle: %s", file);
+                  applyLinkedResults(linked);
+                  return {
+                    result: source
+                  };
+                }
+              });
+            });
+          }
+        }
+        if (Array.isArray(groupedEntries.css)) {
+          for (const element of groupedEntries.css) {
+            const [file, originalSource] = element;
+            const rawSource = originalSource.source().toString();
+            const cacheKey = file;
+            tasks.push(
+              processCachedTask({
+                cache: compilerOptions.cache,
+                cacheKey,
+                rawSource,
+                applyResult(source) {
+                  compilation.updateAsset(file, source);
+                },
+                onCacheHit() {
+                  debug2("css cache hit: %s", file);
+                },
+                transform: async () => {
+                  await runtimeState.patchPromise;
+                  const { css } = await compilerOptions.styleHandler(rawSource, {
+                    isMainChunk: compilerOptions.mainCssChunkMatcher(file, appType),
+                    postcssOptions: {
+                      options: {
+                        from: file
+                      }
+                    },
+                    majorVersion: runtimeState.twPatcher.majorVersion
+                  });
+                  const source = new ConcatSource(css);
+                  compilerOptions.onUpdate(file, rawSource, css);
+                  debug2("css handle: %s", file);
+                  return {
+                    result: source
+                  };
+                }
+              })
+            );
+          }
+        }
+        pushConcurrentTaskFactories(tasks, jsTaskFactories);
+        await Promise.all(tasks);
+        debug2("end");
+        compilerOptions.onEnd();
+      }
+    );
+  });
+}
+
+// src/bundlers/webpack/BaseUnifiedPlugin/v5-loaders.ts
+import fs from "fs";
+import path2 from "path";
+import process2 from "process";
+function setupWebpackV5Loaders(options) {
+  const {
+    compiler,
+    options: compilerOptions,
+    appType,
+    weappTailwindcssPackageDir: weappTailwindcssPackageDir2,
+    shouldRewriteCssImports,
+    runtimeLoaderPath,
+    runtimeCssImportRewriteLoaderPath,
+    getClassSetInLoader,
+    debug: debug2
+  } = options;
+  const isMpxApp = isMpx(appType);
+  if (shouldRewriteCssImports && isMpxApp) {
+    ensureMpxTailwindcssAliases(compiler, weappTailwindcssPackageDir2);
+  }
+  const runtimeClassSetLoader = runtimeLoaderPath ?? path2.resolve(__dirname, "./weapp-tw-runtime-classset-loader.js");
+  const runtimeCssImportRewriteLoader = shouldRewriteCssImports ? runtimeCssImportRewriteLoaderPath ?? path2.resolve(__dirname, "./weapp-tw-css-import-rewrite-loader.js") : void 0;
+  const runtimeClassSetLoaderExists = fs.existsSync(runtimeClassSetLoader);
+  const runtimeCssImportRewriteLoaderExists = runtimeCssImportRewriteLoader ? fs.existsSync(runtimeCssImportRewriteLoader) : false;
+  const runtimeLoaderRewriteOptions = shouldRewriteCssImports ? {
+    pkgDir: weappTailwindcssPackageDir2,
+    appType
+  } : void 0;
+  const classSetLoaderOptions = {
+    getClassSet: getClassSetInLoader
+  };
+  const { findRewriteAnchor, findClassSetAnchor } = createLoaderAnchorFinders(appType);
+  const cssImportRewriteLoaderOptions = runtimeLoaderRewriteOptions ? {
+    rewriteCssImports: runtimeLoaderRewriteOptions
+  } : void 0;
+  if (runtimeCssImportRewriteLoader && shouldRewriteCssImports && cssImportRewriteLoaderOptions && isMpxApp) {
+    injectMpxCssRewritePreRules(compiler, runtimeCssImportRewriteLoader, cssImportRewriteLoaderOptions);
+  }
+  const createRuntimeClassSetLoaderEntry = () => ({
+    loader: runtimeClassSetLoader,
+    options: classSetLoaderOptions,
+    ident: null,
+    type: null
+  });
+  const createCssImportRewriteLoaderEntry = () => {
+    if (!runtimeCssImportRewriteLoader) {
+      return null;
+    }
+    return {
+      loader: runtimeCssImportRewriteLoader,
+      options: cssImportRewriteLoaderOptions,
+      ident: null,
+      type: null
+    };
+  };
+  const { NormalModule } = compiler.webpack;
+  compiler.hooks.compilation.tap(pluginName, (compilation) => {
+    NormalModule.getCompilationHooks(compilation).loader.tap(pluginName, (_loaderContext, module) => {
+      const hasRuntimeLoader = runtimeClassSetLoaderExists || runtimeCssImportRewriteLoaderExists;
+      if (!hasRuntimeLoader) {
+        return;
+      }
+      patchMpxLoaderResolve(_loaderContext, weappTailwindcssPackageDir2, shouldRewriteCssImports && isMpxApp);
+      const loaderEntries = module.loaders || [];
+      let rewriteAnchorIdx = findRewriteAnchor(loaderEntries);
+      const classSetAnchorIdx = findClassSetAnchor(loaderEntries);
+      const isCssModule = isCssLikeModuleResource(module.resource, compilerOptions.cssMatcher, appType);
+      if (process2.env.WEAPP_TW_LOADER_DEBUG && isCssModule) {
+        debug2("loader hook css module: %s loaders=%o anchors=%o", module.resource, loaderEntries.map((x) => x.loader), { rewriteAnchorIdx, classSetAnchorIdx });
+      }
+      if (process2.env.WEAPP_TW_LOADER_DEBUG && typeof module.resource === "string" && module.resource.includes("app.css")) {
+        debug2("app.css module loaders=%o anchors=%o", loaderEntries.map((x) => x.loader), { rewriteAnchorIdx, classSetAnchorIdx });
+      } else if (process2.env.WEAPP_TW_LOADER_DEBUG && typeof module.resource === "string" && module.resource.endsWith(".css")) {
+        debug2("css module seen: %s loaders=%o anchors=%o", module.resource, loaderEntries.map((x) => x.loader), { rewriteAnchorIdx, classSetAnchorIdx });
+      }
+      if (rewriteAnchorIdx === -1 && classSetAnchorIdx === -1 && !isCssModule) {
+        return;
+      }
+      const anchorlessInsert = (entry, position) => {
+        if (position === "after") {
+          loaderEntries.push(entry);
+        } else {
+          loaderEntries.unshift(entry);
+        }
+      };
+      if (cssImportRewriteLoaderOptions && runtimeCssImportRewriteLoaderExists && runtimeCssImportRewriteLoader) {
+        const existingIndex = loaderEntries.findIndex((entry) => entry.loader?.includes?.(runtimeCssImportRewriteLoader));
+        const rewriteLoaderEntry = existingIndex !== -1 ? loaderEntries.splice(existingIndex, 1)[0] : createCssImportRewriteLoaderEntry();
+        if (rewriteLoaderEntry) {
+          const anchorIndex = findRewriteAnchor(loaderEntries);
+          if (anchorIndex === -1) {
+            anchorlessInsert(rewriteLoaderEntry, "after");
+          } else {
+            loaderEntries.splice(anchorIndex + 1, 0, rewriteLoaderEntry);
+          }
+          rewriteAnchorIdx = findRewriteAnchor(loaderEntries);
+        }
+      }
+      if (runtimeClassSetLoaderExists && !hasLoaderEntry(loaderEntries, runtimeClassSetLoader)) {
+        const classSetLoaderEntry = createRuntimeClassSetLoaderEntry();
+        const anchorIndex = findClassSetAnchor(loaderEntries);
+        if (anchorIndex === -1) {
+          anchorlessInsert(classSetLoaderEntry, "before");
+        } else {
+          const insertIndex = anchorIndex === -1 ? rewriteAnchorIdx : anchorIndex;
+          loaderEntries.splice(insertIndex, 0, classSetLoaderEntry);
+        }
+      }
+    });
+  });
+}
+
+// src/bundlers/webpack/BaseUnifiedPlugin/v5.ts
+var debug = createDebug();
+var weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
+var UnifiedWebpackPluginV5 = class {
+  constructor(options = {}) {
+    this.options = getCompilerContext(options);
+    this.appType = this.options.appType;
+  }
+  apply(compiler) {
+    compiler.options = compiler.options || {};
+    const {
+      disabled,
+      onLoad,
+      runtimeLoaderPath,
+      runtimeCssImportRewriteLoaderPath,
+      twPatcher: initialTwPatcher,
+      refreshTailwindcssPatcher
+    } = this.options;
+    const disabledOptions = resolveDisabledOptions(disabled);
+    const isTailwindcssV4 = (initialTwPatcher.majorVersion ?? 0) >= 4;
+    const shouldRewriteCssImports = isTailwindcssV4 && this.options.rewriteCssImports !== false && !disabledOptions.rewriteCssImports;
+    const isMpxApp = isMpx(this.appType);
+    if (shouldRewriteCssImports) {
+      applyTailwindcssCssImportRewrite(compiler, {
+        pkgDir: weappTailwindcssPackageDir,
+        enabled: true,
+        appType: this.appType
+      });
+      setupMpxTailwindcssRedirect(weappTailwindcssPackageDir, isMpxApp);
+    }
+    if (disabledOptions.plugin) {
+      return;
+    }
+    const patchRecorderState = setupPatchRecorder(initialTwPatcher, this.options.tailwindcssBasedir, {
+      source: "runtime",
+      cwd: this.options.tailwindcssBasedir ?? process3.cwd()
+    });
+    const runtimeState = {
+      twPatcher: initialTwPatcher,
+      patchPromise: patchRecorderState.patchPromise,
+      refreshTailwindcssPatcher,
+      onPatchCompleted: patchRecorderState.onPatchCompleted
+    };
+    const refreshRuntimeState = async (force) => {
+      await refreshTailwindRuntimeState(runtimeState, force);
+    };
+    async function getClassSetInLoader() {
+      await refreshRuntimeState(true);
+      await runtimeState.patchPromise;
+      await collectRuntimeClassSet(runtimeState.twPatcher, { force: true, skipRefresh: true });
+    }
+    onLoad();
+    setupWebpackV5Loaders({
+      compiler,
+      options: this.options,
+      appType: this.appType,
+      weappTailwindcssPackageDir,
+      shouldRewriteCssImports,
+      runtimeLoaderPath,
+      runtimeCssImportRewriteLoaderPath,
+      getClassSetInLoader,
+      debug
+    });
+    setupWebpackV5ProcessAssetsHook({
+      compiler,
+      options: this.options,
+      appType: this.appType,
+      runtimeState,
+      refreshRuntimeState,
+      debug
+    });
+  }
+};
+
+export {
+  weappTailwindcssPackageDir,
+  UnifiedWebpackPluginV5
+};

package/dist/{chunk-FFGR5V3H.mjs → chunk-SPH6SCTM.mjs}

@@ -1,4 +1,4 @@
-// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.55.2_@types+node@24.10.4__@swc+core@1.15.7_@swc+h_4d5dc336679991eff78ae0f04625a6b1/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.55.2_@types+node@24.10.9__@swc+core@1.15.10_@swc+_ff0c9e72feaa13fcd6be33c9c3d4ff4d/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename = () => fileURLToPath(import.meta.url);