weapp-tailwindcss
Version:
把 tailwindcss 原子化样式思想，带给小程序开发者们! bring tailwindcss to miniprogram developers!
825 lines (824 loc) • 144 kB
JavaScript
const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
const require_generator = require("./generator-BE34PYSC.cjs");
const require_object = require("./object-C_Vr6_S5.cjs");
const require_options = require("./options-hVsoTfwL.cjs");
const require_utils = require("./utils-CuKLf1Zv.cjs");
const require_v4_generation_core = require("./v4-generation-core-CDI6ChiH.cjs");
const require_wxml = require("./wxml-DSMNuUaP.cjs");
const require_hmr_timing = require("./hmr-timing-Cye_A4mI.cjs");
const require_context = require("./context-OqD_eBxQ.cjs");
const require_tailwindcss = require("./tailwindcss-DcpiKvmJ.cjs");
const require_style_options = require("./style-options-B_ppaVIg.cjs");
const require_source_candidate_scan_signature = require("./source-candidate-scan-signature-D4X_VprL.cjs");
const require_pipeline_helpers = require("./pipeline-helpers-DMO0otI8.cjs");
const require_css_loader_runtime = require("./css-loader-runtime-CSv0lKqV.cjs");
const require_runtime_registry = require("./runtime-registry-Y7NrD2WH.cjs");
let node_fs = require("node:fs");
node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
let node_path = require("node:path");
node_path = require_rolldown_runtime.__toESM(node_path, 1);
let node_process = require("node:process");
node_process = require_rolldown_runtime.__toESM(node_process, 1);
let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
let node_module = require("node:module");
node_module = require_rolldown_runtime.__toESM(node_module, 1);
let node_fs_promises = require("node:fs/promises");
let micromatch = require("micromatch");
micromatch = require_rolldown_runtime.__toESM(micromatch, 1);
let _weapp_core_escape = require("@weapp-core/escape");
let _weapp_tailwindcss_shared_node = require("@weapp-tailwindcss/shared/node");
//#region src/bundlers/webpack/BaseUnifiedPlugin/shared.ts
function getCacheKey(filename) {
return filename;
}
function stripResourceQuery(resource) {
if (typeof resource !== "string") return resource;
return require_v4_generation_core.stripRequestQuery(resource);
}
function isCssLikeModuleResource(resource, cssMatcher) {
if (typeof resource !== "string") return false;
const normalizedResource = stripResourceQuery(resource);
if (normalizedResource && cssMatcher(normalizedResource)) return true;
if (require_v4_generation_core.isSourceStyleRequest(resource)) return true;
return false;
}
function hasLoaderEntry(entries, target) {
if (!target) return false;
return entries.some((entry) => entry.loader?.includes?.(target));
}
function normalizeWatchPath(file) {
return node_path.default.resolve(file);
}
function isFileInContext(file, context) {
const relative = node_path.default.relative(normalizeWatchPath(context), normalizeWatchPath(file));
return relative.length > 0 && !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
}
function toChunkFiles(files) {
if (!files) return [];
if (Array.isArray(files)) return files;
return [...files];
}
function inferWebpackMainCssFiles(chunks, cssMatcher, options = {}) {
const mainCssFiles = /* @__PURE__ */ new Set();
const shouldCheckSourceResources = Boolean(options.mainSourceFiles?.size);
for (const chunk of chunks) {
const files = toChunkFiles(chunk.files);
if (!(chunk.hasRuntime?.() === true)) continue;
for (const file of files) {
if (!cssMatcher(file)) continue;
if (shouldCheckSourceResources) {
const resources = options.resourcesByAsset?.get(file);
if (!resources || ![...resources].some((resource) => options.mainSourceFiles?.has(resource))) continue;
}
mainCssFiles.add(file);
}
}
return mainCssFiles;
}
function resolveSingleActiveWebpackCssResource(assetResources, activeWebpackAssetResourceFiles) {
const activeAssetResourceMatches = [...assetResources ?? []].map((sourceFile) => node_path.default.resolve(sourceFile)).filter((sourceFile) => activeWebpackAssetResourceFiles.has(sourceFile)).sort();
return activeAssetResourceMatches.length === 1 ? activeAssetResourceMatches[0] : void 0;
}
function resolveWebpackCssModuleIdentifierResource(module) {
if (!module.type?.startsWith("css/") || typeof module.identifier !== "function") return;
const identifier = module.identifier();
const request = identifier.startsWith("css|") ? identifier.slice(4) : identifier;
const resourceWithMetadata = request.slice(request.lastIndexOf("!") + 1);
const metadataIndex = resourceWithMetadata.indexOf("|");
return metadataIndex === -1 ? resourceWithMetadata : resourceWithMetadata.slice(0, metadataIndex);
}
function createWebpackCssAssetResourceMapInternal(chunks, chunkGraph, cssMatcher, normalizeResource, onlyUnambiguousCssAssets) {
const resourcesByAsset = /* @__PURE__ */ new Map();
if (!chunkGraph?.getChunkModulesIterable) return resourcesByAsset;
const collectModuleResources = (module, resources, seen = /* @__PURE__ */ new Set()) => {
if (!module || seen.has(module)) return;
seen.add(module);
const candidates = [
module.resource,
module.request,
module.userRequest
];
if (onlyUnambiguousCssAssets) candidates.push(resolveWebpackCssModuleIdentifierResource(module));
for (const candidate of candidates) {
if (typeof candidate !== "string") continue;
const normalized = normalizeResource(candidate, module);
if (normalized) resources.add(normalized);
}
for (const nested of [module.rootModule, chunkGraph.getIssuer?.(module)]) if (nested) collectModuleResources(nested, resources, seen);
for (const nested of module.modules ?? []) collectModuleResources(nested, resources, seen);
for (const dependency of module.dependencies ?? []) {
const dependencyLike = dependency;
for (const candidate of [dependencyLike.request, dependencyLike.userRequest]) {
if (typeof candidate !== "string") continue;
const normalized = normalizeResource(candidate, module);
if (normalized) resources.add(normalized);
}
const dependencyModule = chunkGraph.getModule?.(dependency);
if (dependencyModule) collectModuleResources(dependencyModule, resources, seen);
}
};
for (const chunk of chunks) {
const cssFiles = toChunkFiles(chunk.files).filter((file) => cssMatcher(file));
if (cssFiles.length === 0 || onlyUnambiguousCssAssets && cssFiles.length !== 1) continue;
const modules = chunkGraph.getChunkModulesIterable(chunk);
if (!modules) continue;
const cssResources = /* @__PURE__ */ new Set();
for (const module of modules) collectModuleResources(module, cssResources);
if (cssResources.size === 0) continue;
for (const cssFile of cssFiles) resourcesByAsset.set(cssFile, cssResources);
}
return resourcesByAsset;
}
function createWebpackCssAssetResourceMap(chunks, chunkGraph, cssMatcher, normalizeResource) {
return createWebpackCssAssetResourceMapInternal(chunks, chunkGraph, cssMatcher, normalizeResource, false);
}
function createWebpackDirectCssAssetResourceMap(chunks, chunkGraph, cssMatcher, normalizeResource) {
return createWebpackCssAssetResourceMapInternal(chunks, chunkGraph, cssMatcher, normalizeResource, true);
}
function createAssetHashByChunkMap(chunks) {
const partsByFile = /* @__PURE__ */ new Map();
for (const chunk of chunks) {
const hash = typeof chunk.hash === "string" ? chunk.hash : void 0;
if (!hash) continue;
const chunkId = String(chunk.id ?? chunk.name ?? "");
for (const file of toChunkFiles(chunk.files)) {
if (!file) continue;
let parts = partsByFile.get(file);
if (!parts) {
parts = [];
partsByFile.set(file, parts);
}
parts.push(`${chunkId}:${hash}`);
}
}
const hashByFile = /* @__PURE__ */ new Map();
for (const [file, parts] of partsByFile.entries()) hashByFile.set(file, parts.sort().join("|"));
return hashByFile;
}
function createRuntimeAwareCssHash(assetHash, sourceHash, runtimeSetHash) {
return `${assetHash ?? sourceHash}:${runtimeSetHash}`;
}
function isWatchFileInRuntimeDependencies(file, dependencies) {
const normalizedFile = normalizeWatchPath(file);
for (const dependency of dependencies.files ?? []) if (normalizeWatchPath(dependency) === normalizedFile) return true;
for (const context of dependencies.contexts ?? []) if (isFileInContext(normalizedFile, context)) return true;
return false;
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers/resources.ts
function isWindowsAbsoluteResourcePath(file) {
return /^[a-z]:[\\/]/i.test(file) || /^[/\\]{2}[^/\\]/.test(file);
}
function isPosixAbsoluteResourcePath(file) {
return file.startsWith("/");
}
function resolveWebpackResourcePath(file, base) {
if (isWindowsAbsoluteResourcePath(file)) return node_path.default.win32.resolve(file);
if (isPosixAbsoluteResourcePath(file)) return node_path.default.posix.resolve(file);
if (base) {
if (isWindowsAbsoluteResourcePath(base)) return node_path.default.win32.resolve(base, file);
if (isPosixAbsoluteResourcePath(base)) return node_path.default.posix.resolve(base, file);
return node_path.default.resolve(base, file);
}
}
function dirnameWebpackResourcePath(file) {
if (isWindowsAbsoluteResourcePath(file)) return node_path.default.win32.dirname(file);
if (isPosixAbsoluteResourcePath(file)) return node_path.default.posix.dirname(file);
return node_path.default.dirname(file);
}
function resolveWebpackCssAssetModuleResource(resource, issuer, options) {
if (!isCssLikeModuleResource(resource, options.cssMatcher, options.appType)) return;
const normalized = stripResourceQuery(resource);
if (!normalized) return;
const absoluteResource = resolveWebpackResourcePath(normalized);
if (absoluteResource) return absoluteResource;
const issuerResource = issuer?.resource ? stripResourceQuery(issuer.resource) : void 0;
const issuerResourcePath = issuerResource ? resolveWebpackResourcePath(issuerResource) : void 0;
return resolveWebpackResourcePath(normalized, issuerResourcePath ? dirnameWebpackResourcePath(issuerResourcePath) : issuer?.context);
}
function isSameWebpackCssSourceScope(options) {
if (!options.currentSourceFile) return false;
const candidateKey = resolveWebpackResourcePath(options.candidateSourceFile) ?? node_path.default.resolve(options.candidateSourceFile);
if (candidateKey === (resolveWebpackResourcePath(options.currentSourceFile) ?? node_path.default.resolve(options.currentSourceFile))) return true;
const outputResources = options.resourcesByAsset.get(options.outputFile);
if (!outputResources) return false;
return [...outputResources].some((resource) => {
return (resolveWebpackResourcePath(resource) ?? node_path.default.resolve(resource)) === candidateKey;
});
}
function shouldAppendCurrentWebpackAssetUserCss(options) {
const hasGeneratedAssetUserCss = options.currentAssetLooksGenerated && options.currentAssetHasUserCss;
return !options.currentAssetHasBundlerGeneratedMarker && !options.shouldPreserveGeneratedWebAssetUserCss && (hasGeneratedAssetUserCss || !options.sourceCssProcessed || options.registeredUserRawSource === void 0 || options.currentAssetHasUserCss) && !(options.sourceCssProcessed && options.currentAssetLooksGenerated && !options.currentAssetHasUserCss);
}
function createWebpackCurrentAssetUserRawSource(options) {
if (!options.shouldAppendCurrentAssetUserCss) return;
if (options.sourceCssProcessed) return {
css: options.currentAssetUserCssSource,
processed: true
};
if (!options.currentAssetHasUserCss) return;
return {
css: options.currentAssetUserCssSource,
processed: options.currentAssetLooksGenerated
};
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/css-source-resolvers.ts
function normalizeWebpackCssSourceRef(file) {
return file.replaceAll("\\", "/");
}
function collectWebpackCssTokenSourceRefs(source) {
const refs = /* @__PURE__ */ new Set();
for (const line of source.split("\n")) {
if (!line.includes("/* tokens:") || !line.includes("<=")) continue;
const traceStart = line.indexOf("<=");
const traceEnd = line.indexOf("*/", traceStart);
const trace = line.slice(traceStart + 2, traceEnd >= 0 ? traceEnd : void 0);
for (const segment of trace.split("|")) {
const sourceList = segment.replace(/^[^<]*<=\s*/, "").split(",");
for (const ref of sourceList) {
const normalizedRef = ref.trim();
if (normalizedRef) refs.add(normalizeWebpackCssSourceRef(normalizedRef));
}
}
}
return refs;
}
function readWebpackCompilationAssetSource(compilation, file) {
const source = compilation.getAsset?.(file)?.source?.source?.();
if (source === void 0) return;
return typeof source === "string" ? source : source.toString();
}
function resolveWebpackCssImportFile(file, request) {
if (/^(?:https?:)?\/\//i.test(request) || request.startsWith("/")) return;
if (!/\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i.test(request)) return;
const cleanRequest = request.replace(/[?#].*$/, "");
return normalizeWebpackCssSourceRef(node_path.default.posix.join(node_path.default.posix.dirname(normalizeWebpackCssSourceRef(file)), cleanRequest));
}
function collectCssImportRequests(source) {
return [...source.matchAll(/@import\s+(?:url\(\s*)?(?:"([^"]+)"|'([^']+)'|([^\s;)]+))/g)].map((match) => match[1] ?? match[2] ?? match[3]).filter((request) => typeof request === "string" && request.length > 0);
}
function collectMainImportedCssFiles(compilation, cssAssetFiles, cssMatcher, isMainCssFile) {
const files = /* @__PURE__ */ new Set();
const candidates = new Set(cssAssetFiles);
for (const chunk of compilation.chunks) for (const file of chunk.files ?? []) candidates.add(file);
for (const file of candidates) {
if (!cssMatcher(file) || !isMainCssFile(file)) continue;
const source = readWebpackCompilationAssetSource(compilation, file);
if (!source?.includes("@import")) continue;
for (const request of collectCssImportRequests(source)) {
const importedFile = resolveWebpackCssImportFile(file, request);
if (importedFile) files.add(importedFile);
}
}
return files;
}
function createWebpackCssSourceResolvers(options) {
const { activeWebpackAssetResourceFiles, appType, compilerOptions, compilation, cssAssetFiles, cssAssetResources, directCssAssetResources, cssHandlerOptionsCache, cssSources, cssUserHandlerOptionsCache, groupedCssEntriesLength, singleCssAssetFile, isWebGeneratorTarget, outputDir, runtimeState } = options;
const hasConfiguredTailwindV4SourceRoots = () => {
const tailwindOptions = require_generator.resolveTailwindcssOptions(runtimeState.tailwindRuntime.options);
return (tailwindOptions?.v4?.cssEntries?.length ?? 0) > 0 || (tailwindOptions?.v4?.cssSources?.length ?? 0) > 0;
};
const configuredCssEntryFiles = (() => {
const tailwindOptions = require_generator.resolveTailwindcssOptions(runtimeState.tailwindRuntime.options);
const entries = [...compilerOptions.cssEntries ?? [], ...tailwindOptions?.v4?.cssEntries ?? []].filter((file) => typeof file === "string" && file.length > 0).map((file) => node_path.default.resolve(file));
return [...new Set(entries)];
})();
const configuredMainCssEntryFiles = configuredCssEntryFiles.slice(0, 1);
const scoreCssSourceOutputMatch = (file, sourceFile) => require_v4_generation_core.scoreTailwindV4CssSourceFileMatch(file, sourceFile, {
outputRoot: outputDir,
projectRoot: compilerOptions.tailwindcssBasedir,
cwd: compilerOptions.tailwindcssBasedir
});
const isConfiguredMainCssEntryFile = (sourceFile) => configuredMainCssEntryFiles.some((entry) => node_path.default.resolve(entry) === node_path.default.resolve(sourceFile));
const isCssSourceAllowedForOutput = (file, sourceFile) => !isConfiguredMainCssEntryFile(sourceFile) || directCssAssetResources.get(file)?.has(sourceFile) === true || scoreCssSourceOutputMatch(file, sourceFile) > 0;
const inferredMainCssFiles = new Set([...inferWebpackMainCssFiles(compilation.chunks, compilerOptions.cssMatcher, {
mainSourceFiles: new Set(configuredMainCssEntryFiles),
resourcesByAsset: cssAssetResources
})].filter((file) => {
if (configuredMainCssEntryFiles.length === 0) return true;
return [...cssAssetResources.get(file) ?? []].some((resource) => isConfiguredMainCssEntryFile(resource) && isCssSourceAllowedForOutput(file, resource));
}));
const mainImportedCssFiles = collectMainImportedCssFiles(compilation, cssAssetFiles, compilerOptions.cssMatcher, (file) => compilerOptions.mainCssChunkMatcher(file, appType) || inferredMainCssFiles.has(file));
const singleConfiguredCssAsset = isWebGeneratorTarget && configuredMainCssEntryFiles.length > 0 && groupedCssEntriesLength === 1 ? singleCssAssetFile : void 0;
const isMainCssChunk = (file) => {
const resources = cssAssetResources.get(file);
if (resources && configuredCssEntryFiles.length > 0) for (const resource of resources) {
const index = configuredCssEntryFiles.findIndex((entry) => node_path.default.resolve(entry) === node_path.default.resolve(resource));
if (index >= 0) return index === 0;
}
if (configuredCssEntryFiles.length > 1) return false;
return compilerOptions.mainCssChunkMatcher(file, appType) || inferredMainCssFiles.has(file) || mainImportedCssFiles.has(normalizeWebpackCssSourceRef(file)) || file === singleConfiguredCssAsset;
};
const activeWebpackCssSourceFiles = /* @__PURE__ */ new Set();
const resolveConfiguredMainCssSourceFile = (file) => {
if (!isMainCssChunk(file)) return;
if (configuredMainCssEntryFiles.length !== 1) return;
if (groupedCssEntriesLength !== 1 && file !== singleCssAssetFile) return;
for (const sourceFile of configuredMainCssEntryFiles) if (cssSources.has(sourceFile)) {
activeWebpackCssSourceFiles.add(sourceFile);
return sourceFile;
}
};
const resolveWebpackCssSourceFile = (file, rawSource) => {
const assetResources = cssAssetResources.get(file);
const activeAssetResource = resolveSingleActiveWebpackCssResource(assetResources, activeWebpackAssetResourceFiles);
if (cssSources.size === 0) {
if (activeAssetResource && isCssSourceAllowedForOutput(file, activeAssetResource)) {
activeWebpackCssSourceFiles.add(activeAssetResource);
return activeAssetResource;
}
if (assetResources && assetResources.size > 0) return;
return resolveConfiguredMainCssSourceFile(file);
}
const resourceMatches = [...assetResources ?? []].filter((sourceFile) => cssSources.has(sourceFile)).filter((sourceFile) => isCssSourceAllowedForOutput(file, sourceFile)).sort();
const configuredResourceMatches = resourceMatches.filter((sourceFile) => configuredCssEntryFiles.some((entry) => node_path.default.resolve(entry) === node_path.default.resolve(sourceFile)));
if (configuredResourceMatches.length === 1) {
const sourceFile = configuredResourceMatches[0];
activeWebpackCssSourceFiles.add(sourceFile);
return sourceFile;
}
if (resourceMatches.length === 1) {
const sourceFile = resourceMatches[0];
activeWebpackCssSourceFiles.add(sourceFile);
return sourceFile;
}
const tailwindSourceMatches = resourceMatches.filter((sourceFile) => {
const sourceCss = cssSources.get(sourceFile)?.css;
return sourceCss && (require_generator.hasTailwindRootDirectives(sourceCss, { importFallback: true }) || require_generator.hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || require_generator.hasTailwindApplyDirective(sourceCss) || require_generator.hasTailwindGeneratedCss(sourceCss) || require_generator.hasTailwindGeneratedCssMarkers(sourceCss));
});
if (tailwindSourceMatches.length === 1) {
const sourceFile = tailwindSourceMatches[0];
activeWebpackCssSourceFiles.add(sourceFile);
return sourceFile;
}
if (activeAssetResource && isCssSourceAllowedForOutput(file, activeAssetResource)) {
activeWebpackCssSourceFiles.add(activeAssetResource);
return activeAssetResource;
}
if (rawSource) {
const tokenSourceRefs = collectWebpackCssTokenSourceRefs(rawSource);
if (tokenSourceRefs.size > 0) {
const tokenSourceMatches = [...cssSources.keys()].filter((sourceFile) => {
const relativeSourceFile = normalizeWebpackCssSourceRef(node_path.default.relative(compilerOptions.tailwindcssBasedir, sourceFile));
const absoluteSourceFile = normalizeWebpackCssSourceRef(node_path.default.resolve(sourceFile));
return tokenSourceRefs.has(relativeSourceFile) || tokenSourceRefs.has(absoluteSourceFile);
}).sort();
if (tokenSourceMatches.length === 1) {
const sourceFile = tokenSourceMatches[0];
activeWebpackCssSourceFiles.add(sourceFile);
return sourceFile;
}
}
const representedTailwindSourceMatches = [...cssSources.entries()].filter(([, source]) => require_pipeline_helpers.isWebpackCssSourceRepresentedInAsset(rawSource, source.css)).map(([sourceFile]) => ({
sourceFile,
score: require_v4_generation_core.scoreTailwindV4CssSourceFileMatch(file, sourceFile, {
outputRoot: outputDir,
projectRoot: compilerOptions.tailwindcssBasedir,
cwd: compilerOptions.tailwindcssBasedir
})
})).filter((match) => match.score > 0).sort((a, b) => b.score - a.score || a.sourceFile.localeCompare(b.sourceFile));
const bestScore = representedTailwindSourceMatches[0]?.score ?? 0;
const bestMatches = representedTailwindSourceMatches.filter((match) => match.score === bestScore);
if (bestMatches.length === 1) {
const sourceFile = bestMatches[0].sourceFile;
activeWebpackCssSourceFiles.add(sourceFile);
return sourceFile;
}
}
const pathMatches = [...cssSources.keys()].map((sourceFile) => ({
sourceFile,
score: require_v4_generation_core.scoreTailwindV4CssSourceFileMatch(file, sourceFile, {
outputRoot: outputDir,
projectRoot: compilerOptions.tailwindcssBasedir,
cwd: compilerOptions.tailwindcssBasedir
})
})).filter((match) => match.score >= 1e3).sort((a, b) => b.score - a.score || a.sourceFile.localeCompare(b.sourceFile));
const bestPathScore = pathMatches[0]?.score ?? 0;
const bestPathMatches = pathMatches.filter((match) => match.score === bestPathScore);
if (bestPathMatches.length === 1) {
const sourceFile = bestPathMatches[0].sourceFile;
activeWebpackCssSourceFiles.add(sourceFile);
return sourceFile;
}
if (assetResources && assetResources.size > 0) return;
return resolveConfiguredMainCssSourceFile(file);
};
const isSameWebpackSourceScope = (outputFile, candidateSourceFile, currentSourceFile) => isSameWebpackCssSourceScope({
candidateSourceFile,
currentSourceFile,
outputFile,
resourcesByAsset: cssAssetResources
});
const getCssHandlerOptions = (file, rawSource) => {
const majorVersion = runtimeState.tailwindRuntime.majorVersion;
const isMainCssAsset = isMainCssChunk(file);
const sourceFile = resolveWebpackCssSourceFile(file, rawSource);
const sourceMatchedMainCssEntry = sourceFile !== void 0 && isConfiguredMainCssEntryFile(sourceFile) && isCssSourceAllowedForOutput(file, sourceFile);
const isMainChunk = isMainCssAsset || sourceMatchedMainCssEntry;
const sourceCss = sourceFile ? cssSources.get(sourceFile)?.css : void 0;
const generatorSourceCss = require_pipeline_helpers.removeWebpackGeneratorNonTailwindImports(sourceCss);
const generatorCssSource = require_pipeline_helpers.createWebpackGeneratorCssSource(sourceFile, generatorSourceCss);
const cacheKey = [
majorVersion ?? "unknown",
isMainChunk ? "1" : "0",
sourceFile ?? "asset",
sourceCss === void 0 ? "source:0" : compilerOptions.cache.computeHash(sourceCss),
generatorSourceCss === sourceCss || generatorSourceCss === void 0 ? "generator-source:0" : compilerOptions.cache.computeHash(generatorSourceCss),
file
].join(":");
const cached = cssHandlerOptionsCache.get(cacheKey);
if (cached) return cached;
const created = {
isMainChunk,
postcssOptions: { options: { from: sourceFile ?? file } },
sourceOptions: {
outputRoot: outputDir,
...generatorCssSource === void 0 ? {} : { cssSources: [generatorCssSource] },
...generatorSourceCss === void 0 ? {} : { sourceCss: generatorSourceCss },
...sourceFile === void 0 ? {} : { sourceFile }
},
...require_style_options.normalizeStyleHandlerMajorVersion(majorVersion) === void 0 ? {} : { majorVersion: 4 }
};
cssHandlerOptionsCache.set(cacheKey, created);
return created;
};
const getCssUserHandlerOptions = (file) => {
const majorVersion = runtimeState.tailwindRuntime.majorVersion;
const sourceFile = resolveWebpackCssSourceFile(file);
const sourceCss = sourceFile ? cssSources.get(sourceFile)?.css : void 0;
const generatorSourceCss = require_pipeline_helpers.removeWebpackGeneratorNonTailwindImports(sourceCss);
const cacheKey = [
majorVersion ?? "unknown",
sourceFile ?? "asset",
sourceCss === void 0 ? "source:0" : compilerOptions.cache.computeHash(sourceCss),
generatorSourceCss === sourceCss || generatorSourceCss === void 0 ? "generator-source:0" : compilerOptions.cache.computeHash(generatorSourceCss),
file
].join(":");
const cached = cssUserHandlerOptionsCache.get(cacheKey);
if (cached) return cached;
const created = {
...getCssHandlerOptions(file),
isMainChunk: false
};
cssUserHandlerOptionsCache.set(cacheKey, created);
return created;
};
return {
activeWebpackCssSourceFiles,
configuredCssEntryFiles,
configuredMainCssEntryFiles,
getCssHandlerOptions,
getCssUserHandlerOptions,
hasConfiguredTailwindV4SourceRoots,
isSameWebpackSourceScope,
resolveWebpackCssSourceFile
};
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/finalize-assets.ts
async function finalizeWebpackProcessAssets(context) {
const { activeProcessCacheKeys, activeProcessHashKeys, activeWebpackCssSourceFiles, compilerOptions, cssAssetResources, cssHandlerOptionsCache, cssTaskFactories, cssUserHandlerOptionsCache, debug, entries, groupedEntries, hmrTimingStartedAt, htmlTaskFactories, jsTaskFactories, pruneWebpackCssSources, recordTimingDetail, registeredWebpackCssSourceFiles, taskConcurrency, tasks, timingDetails, watchMode, webpackSourceCandidateScanCache } = context;
if (!watchMode) {
require_v4_generation_core.pushConcurrentTaskFactories(tasks, htmlTaskFactories, taskConcurrency);
await Promise.all(tasks);
tasks.length = 0;
require_v4_generation_core.pushConcurrentTaskFactories(tasks, jsTaskFactories, taskConcurrency);
await Promise.all(tasks);
tasks.length = 0;
require_v4_generation_core.pushConcurrentTaskFactories(tasks, cssTaskFactories, taskConcurrency);
}
const taskWaitStartedAt = performance.now();
await Promise.all(tasks);
recordTimingDetail("tasks.wait", taskWaitStartedAt);
const pruneStartedAt = performance.now();
compilerOptions.cache.prune?.({
cacheKeys: activeProcessCacheKeys,
hashKeys: activeProcessHashKeys
});
const activeCssFiles = new Set(groupedEntries.css.map(([file]) => file));
require_pipeline_helpers.pruneWebpackCssHandlerOptionCaches(cssHandlerOptionsCache, cssUserHandlerOptionsCache, activeCssFiles);
if (activeCssFiles.size > 0) pruneWebpackCssSources?.(/* @__PURE__ */ new Set([
...registeredWebpackCssSourceFiles,
...activeWebpackCssSourceFiles,
...[...cssAssetResources.values()].flatMap((resources) => [...resources])
]), { watchMode });
recordTimingDetail("cache.prune", pruneStartedAt);
debug("end");
require_hmr_timing.emitHmrTiming("webpack", "processAssets", performance.now() - hmrTimingStartedAt, {
...timingDetails,
memoryDebug: require_pipeline_helpers.resolveWebpackMemoryDebugStats({
activeAssetFiles: entries.length,
activeCssFiles: activeCssFiles.size,
activeProcessCacheKeys,
activeProcessHashKeys,
cache: compilerOptions.cache,
cssHandlerOptionsCache,
cssUserHandlerOptionsCache,
phase: "processAssets",
sourceCandidateScan: webpackSourceCandidateScanCache.getMemoryStats()
})
});
compilerOptions.onEnd();
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/generated-css-result.ts
async function finalizeWebpackGeneratedCssResult(context) {
const { ConcatSource, compilerOptions, cssHandlerOptions, currentRawSource, debug, file, finalizeCssAssetSource, finalizeTracedCss, generated, generatorRawSource, generatorRuntimeSet, isWebGeneratorTarget, runtimeState, shouldPreserveExistingPreflight, sourceCss, sourceCssProcessed, userRawSource } = context;
const finalizedGeneratedCss = generated ? finalizeCssAssetSource(isWebGeneratorTarget && currentRawSource.includes("tailwindcss v4.") ? require_pipeline_helpers.createWebpackGeneratorUserCssSourceAppend({
css: generated.css,
processed: true
}, {
css: require_pipeline_helpers.removeWebpackTailwindGeneratedAssetCss(currentRawSource),
processed: true
})?.css ?? generated.css : generated.css, {
cssPreflight: cssHandlerOptions.isMainChunk,
generatedCss: true,
preserveExistingPreflight: shouldPreserveExistingPreflight
}) : isWebGeneratorTarget ? finalizeCssAssetSource(generatorRawSource, { generatedCss: false }) : finalizeCssAssetSource((await compilerOptions.styleHandler(generatorRawSource, cssHandlerOptions)).css, { generatedCss: false });
const sourceBareUserCss = isWebGeneratorTarget ? void 0 : require_pipeline_helpers.createWebpackGeneratorUserCssSourceAppend(...[
userRawSource,
sourceCss === void 0 ? void 0 : {
css: sourceCss,
processed: sourceCssProcessed
},
{
css: generatorRawSource,
processed: false
}
].map((source) => {
if (source === void 0) return;
return {
css: require_pipeline_helpers.collectWebpackBareSelectorUserCss(source.css),
processed: source.processed
};
}));
const handledSourceBareUserCss = sourceBareUserCss === void 0 ? "" : sourceBareUserCss.processed ? sourceBareUserCss.css : (await compilerOptions.styleHandler(sourceBareUserCss.css, cssHandlerOptions)).css;
const finalizedSourceBareUserCss = handledSourceBareUserCss.trim().length === 0 ? "" : finalizeCssAssetSource(handledSourceBareUserCss, {
cssPreflight: false,
generatedCss: false
});
const missingSourceBareUserCss = finalizedSourceBareUserCss.trim().length === 0 ? "" : (0, _weapp_tailwindcss_postcss.filterExistingCssRules)(finalizedGeneratedCss, finalizedSourceBareUserCss);
const source = new ConcatSource(finalizeTracedCss(missingSourceBareUserCss.trim().length === 0 ? finalizedGeneratedCss : require_pipeline_helpers.createWebpackGeneratorUserCssSourceAppend({
css: finalizedGeneratedCss,
processed: true
}, {
css: missingSourceBareUserCss,
processed: true
}).css, cssHandlerOptions, { finalized: true }));
if (generated) {
for (const className of generated.classSet) generatorRuntimeSet.add(className);
debug("css handle via tailwind v%s engine(%s): %s", runtimeState.tailwindRuntime.majorVersion, generated.target, file);
} else debug("css handle: %s", file);
return { result: source };
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/generated-css-task.ts
async function processWebpackGeneratedCssAsset(element, context) {
const { ConcatSource, affectedCompilationScopes, assetHashByChunk, compilation, compilationChanges, compilerOptions, configuredCssEntryFiles, configuredMainCssEntryFiles, createRuntimeSetHash, cssSourceTraceSignature, cssSources, cssTaskFactories, debug, enqueueTask, finalizeCssAssetSource, finalizeTracedCss, generatedCssSources, generatorRuntimeSet, getCompilationDependencyRevision, getCssHandlerOptions, getCssUserHandlerOptions, getGeneratorRuntimeSet, hasConfiguredTailwindV4SourceRoots, isSameWebpackSourceScope, isWebGeneratorTarget, rememberProcessCacheKey, resolveWebpackCssSourceFile, runtimeAffectingSourceHash, runtimeState, transformRuntimeSet, updateAssetIfChanged, watchMode, webpackSourceCandidateValueSignature, webpackSourceCandidates } = context;
const [file, originalSource] = element;
const currentRawSource = originalSource.source().toString();
const chunkHash = assetHashByChunk.get(file);
const cacheKey = file;
const hashKey = `${file}:asset`;
rememberProcessCacheKey(cacheKey, hashKey);
const cssHandlerOptionsForHash = getCssHandlerOptions(file, currentRawSource);
const compilationScope = {
id: file,
kind: cssHandlerOptionsForHash.isMainChunk ? "global" : "component"
};
const scopeCompilationChanges = affectedCompilationScopes.has(compilationScope.id) ? compilationChanges : void 0;
const compilationDependencyRevision = getCompilationDependencyRevision(compilationScope.id);
const cssChunkHash = watchMode && cssHandlerOptionsForHash.isMainChunk ? void 0 : chunkHash;
const cssSourceHash = (() => {
const sourceFile = resolveWebpackCssSourceFile(file, currentRawSource);
const sourceCss = sourceFile ? cssSources.get(sourceFile)?.css : void 0;
const generatorSourceCss = require_pipeline_helpers.removeWebpackGeneratorNonTailwindImports(sourceCss);
if (sourceCss === void 0) return sourceFile === void 0 ? "webpack-css-source:0" : `webpack-css-source:0:${sourceFile}`;
return `webpack-css-source:1:${compilerOptions.cache.computeHash(sourceCss)}:${generatorSourceCss === sourceCss || generatorSourceCss === void 0 ? "generator-source:0" : compilerOptions.cache.computeHash(generatorSourceCss)}`;
})();
const runtimeAwareHash = createRuntimeAwareCssHash(cssChunkHash, compilerOptions.cache.computeHash(currentRawSource), `${createRuntimeSetHash(getGeneratorRuntimeSet())}:${runtimeAffectingSourceHash}:${webpackSourceCandidates?.signatureHash ?? "source-candidates:0"}:${webpackSourceCandidateValueSignature}:${cssSourceTraceSignature}:${cssSourceHash}:compiler-dependencies:${compilationDependencyRevision}`);
await enqueueTask(async () => {
await require_hmr_timing.processCachedTask({
cache: compilerOptions.cache,
cacheKey,
hashKey,
rawSource: currentRawSource,
hash: runtimeAwareHash,
applyResult(source, { cacheHit }) {
updateAssetIfChanged(file, source, {
compare: !cacheHit,
notifyUpdate: !cacheHit
});
},
onCacheHit() {
debug("css cache hit: %s", file);
},
transform: async () => {
await runtimeState.readyPromise;
const cssHandlerOptions = getCssHandlerOptions(file, currentRawSource);
const generatorRawSource = require_pipeline_helpers.resolveWebpackGeneratorRawSource(currentRawSource, cssHandlerOptions);
if (require_css_loader_runtime.isWebpackCssLoaderRuntimeSource(generatorRawSource)) return { result: new ConcatSource(currentRawSource) };
const sourceFile = cssHandlerOptions.sourceOptions?.sourceFile;
const sourceCss = sourceFile ? cssSources.get(node_path.default.resolve(sourceFile))?.css : void 0;
const isConfiguredCssSource = sourceFile !== void 0 && configuredCssEntryFiles.some((entry) => node_path.default.resolve(entry) === node_path.default.resolve(sourceFile));
const isConfiguredMainCssSource = sourceFile !== void 0 && configuredMainCssEntryFiles.some((entry) => node_path.default.resolve(entry) === node_path.default.resolve(sourceFile));
const sourceCssHasTailwindRoot = sourceCss !== void 0 && require_generator.hasTailwindRootDirectives(sourceCss, { importFallback: true });
const shouldPreserveExistingPreflight = cssHandlerOptions.isMainChunk || !isConfiguredMainCssSource && (isConfiguredCssSource || sourceCssHasTailwindRoot);
const loaderGeneratedCss = sourceFile ? generatedCssSources.get(node_path.default.resolve(sourceFile)) : void 0;
const shouldRegenerateExplicitTailwindV4CssSource = sourceCss !== void 0 && (require_generator.hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || sourceCss.includes("@config"));
const explicitTailwindV4SourceCandidates = shouldRegenerateExplicitTailwindV4CssSource && sourceCss && sourceFile && webpackSourceCandidates?.getSourceCandidatesForEntries ? await require_options.resolveTailwindV4EntriesFromCssCached(sourceCss, node_path.default.dirname(sourceFile)).then((resolved) => resolved?.entries ? webpackSourceCandidates.getSourceCandidatesForEntries(resolved.entries) : void 0) : void 0;
if (loaderGeneratedCss && require_pipeline_helpers.shouldConsumeWebpackLoaderGeneratedCss({
allowMarkerlessRegistryMatch: configuredCssEntryFiles.length === 1,
hasBundlerGeneratedCssMarker: require_v4_generation_core.hasBundlerGeneratedCssMarker(currentRawSource),
loaderGeneratedClassSet: loaderGeneratedCss.classSet,
sourceCandidates: explicitTailwindV4SourceCandidates,
shouldRegenerateExplicitTailwindV4CssSource,
watchMode
})) {
for (const className of loaderGeneratedCss.classSet) {
generatorRuntimeSet.add(className);
transformRuntimeSet.add(className);
}
for (const dependency of loaderGeneratedCss.dependencies) compilation.fileDependencies?.add?.(dependency);
const currentRawSourceWithoutBundlerMarkers = require_v4_generation_core.stripBundlerGeneratedCssMarkers(currentRawSource);
const currentAssetHasProcessedUrl = require_pipeline_helpers.hasProcessedCssAssetUrl(currentRawSourceWithoutBundlerMarkers) && currentRawSourceWithoutBundlerMarkers !== loaderGeneratedCss.css;
const currentAssetUserCss = currentAssetHasProcessedUrl ? currentRawSourceWithoutBundlerMarkers : require_pipeline_helpers.shouldUseWebpackAssetAsGeneratorUserCss(currentRawSourceWithoutBundlerMarkers, loaderGeneratedCss.css, { processed: true }) ? require_v4_generation_core.removeGeneratedSelectorCompatCss(currentRawSourceWithoutBundlerMarkers, loaderGeneratedCss.css) : void 0;
const loaderGeneratedCssWithoutMarkers = require_v4_generation_core.stripBundlerGeneratedCssMarkers(loaderGeneratedCss.css);
const currentAssetUserCssWithoutMarkers = currentAssetUserCss === void 0 ? "" : require_v4_generation_core.stripBundlerGeneratedCssMarkers(currentAssetUserCss);
const currentAssetMissingUserCss = !(currentAssetUserCssWithoutMarkers.trim().length > 0 && !require_generator.isCommentOnlyCss(currentAssetUserCssWithoutMarkers)) ? "" : (0, _weapp_tailwindcss_postcss.filterExistingCssRules)(currentAssetUserCssWithoutMarkers, loaderGeneratedCssWithoutMarkers);
if (isConfiguredMainCssSource && !cssHandlerOptions.isMainChunk) {
debug("css skip duplicate webpack loader main generation: %s <- %s", file, sourceFile);
const userCss = currentAssetMissingUserCss.trim().length === 0 || require_generator.isCommentOnlyCss(currentAssetMissingUserCss) ? "" : finalizeCssAssetSource(currentAssetMissingUserCss, {
cssPreflight: false,
generatedCss: false
});
return { result: new ConcatSource(finalizeTracedCss(userCss, cssHandlerOptions)) };
}
const mergedLoaderCss = currentAssetUserCss === void 0 ? loaderGeneratedCss.css : require_pipeline_helpers.createWebpackGeneratorUserCssSourceAppend({
css: currentAssetUserCss === void 0 ? loaderGeneratedCss.css : currentAssetHasProcessedUrl ? require_v4_generation_core.removeGeneratedSelectorCompatCss(loaderGeneratedCss.css, currentAssetUserCss) : (0, _weapp_tailwindcss_postcss.filterExistingCssRules)(currentAssetUserCss, loaderGeneratedCss.css),
processed: true
}, currentAssetUserCss === void 0 ? void 0 : {
css: currentAssetUserCss,
processed: true
}).css;
const handledLoaderCss = isWebGeneratorTarget ? mergedLoaderCss : (await compilerOptions.styleHandler(mergedLoaderCss, cssHandlerOptions)).css;
const finalizedLoaderCss = finalizeCssAssetSource(handledLoaderCss, {
cssPreflight: cssHandlerOptions.isMainChunk,
generatedCss: true,
preserveExistingPreflight: shouldPreserveExistingPreflight
});
const loaderSourceBareUserCss = isWebGeneratorTarget ? void 0 : require_pipeline_helpers.createWebpackGeneratorUserCssSourceAppend(...[currentAssetUserCss === void 0 ? void 0 : {
css: currentAssetUserCss,
processed: true
}, sourceCss === void 0 ? void 0 : {
css: sourceCss,
processed: false
}].map((source) => {
if (source === void 0) return;
return {
css: require_pipeline_helpers.collectWebpackBareSelectorUserCss(source.css),
processed: source.processed
};
}));
const handledLoaderSourceBareUserCss = loaderSourceBareUserCss === void 0 ? "" : loaderSourceBareUserCss.processed ? loaderSourceBareUserCss.css : (await compilerOptions.styleHandler(loaderSourceBareUserCss.css, cssHandlerOptions)).css;
const finalizedLoaderSourceBareUserCss = handledLoaderSourceBareUserCss.trim().length === 0 ? "" : finalizeCssAssetSource(handledLoaderSourceBareUserCss, {
cssPreflight: false,
generatedCss: false
});
const missingLoaderSourceBareUserCss = finalizedLoaderSourceBareUserCss.trim().length === 0 ? "" : (0, _weapp_tailwindcss_postcss.filterExistingCssRules)(finalizedLoaderCss, finalizedLoaderSourceBareUserCss);
const css = finalizeTracedCss(missingLoaderSourceBareUserCss.trim().length === 0 ? finalizedLoaderCss : require_pipeline_helpers.createWebpackGeneratorUserCssSourceAppend({
css: finalizedLoaderCss,
processed: true
}, {
css: missingLoaderSourceBareUserCss,
processed: true
}).css, cssHandlerOptions, { finalized: true });
debug("css consume webpack loader generation: %s <- %s", file, sourceFile);
return { result: new ConcatSource(css) };
}
const sourceCssProcessed = sourceFile ? cssSources.get(node_path.default.resolve(sourceFile))?.processed === true : false;
const registeredUserRawSource = require_pipeline_helpers.createWebpackUserCssSourceAppend([...cssSources.entries()].map(([registeredSourceFile, source]) => ({
...source,
file: registeredSourceFile
})), generatorRawSource, sourceFile, (registeredSourceFile) => isSameWebpackSourceScope(file, registeredSourceFile, sourceFile));
const currentAssetLooksGenerated = require_generator.hasTailwindGeneratedCss(currentRawSource) || require_generator.hasTailwindGeneratedCssMarkers(currentRawSource);
const currentAssetHasBundlerGeneratedMarker = require_v4_generation_core.hasBundlerGeneratedCssMarker(currentRawSource);
const currentAssetUserCssSource = currentAssetLooksGenerated ? require_pipeline_helpers.removeWebpackTailwindGeneratedAssetCss(currentRawSource) : currentRawSource;
if (sourceFile === void 0 && currentAssetHasBundlerGeneratedMarker && (currentAssetUserCssSource.trim().length === 0 || require_generator.isCommentOnlyCss(currentAssetUserCssSource))) return { result: new ConcatSource(finalizeTracedCss("", cssHandlerOptions)) };
const currentAssetHasAdditionalUserCss = currentAssetLooksGenerated && (require_pipeline_helpers.hasAdditionalWebpackAssetUserCssMarkers(currentAssetUserCssSource, generatorRawSource) || currentAssetUserCssSource.trim().length > 0);
const shouldPreserveGeneratedWebAssetUserCss = isWebGeneratorTarget && currentAssetLooksGenerated && !currentAssetHasBundlerGeneratedMarker && !currentAssetHasAdditionalUserCss;
const hasExplicitSourceCssForCurrentAsset = sourceCss !== void 0 && (require_generator.hasTailwindRootDirectives(sourceCss, { importFallback: true }) || require_generator.hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || require_generator.hasTailwindApplyDirective(sourceCss));
const currentAssetHasUserCss = (sourceCssProcessed || hasExplicitSourceCssForCurrentAsset) && currentAssetLooksGenerated && !shouldPreserveGeneratedWebAssetUserCss ? currentAssetHasAdditionalUserCss : require_pipeline_helpers.shouldUseWebpackAssetAsGeneratorUserCss(currentAssetUserCssSource, generatorRawSource, { processed: sourceCssProcessed || shouldPreserveGeneratedWebAssetUserCss });
const userRawSource = require_pipeline_helpers.createWebpackGeneratorUserCssSourceAppend(createWebpackCurrentAssetUserRawSource({
currentAssetHasUserCss,
currentAssetLooksGenerated,
currentAssetUserCssSource,
shouldAppendCurrentAssetUserCss: shouldAppendCurrentWebpackAssetUserCss({
currentAssetHasBundlerGeneratedMarker,
currentAssetHasUserCss,
currentAssetLooksGenerated,
registeredUserRawSource,
shouldPreserveGeneratedWebAssetUserCss,
sourceCssProcessed
}),
sourceCssProcessed
}), registeredUserRawSource);
if ((0, _weapp_tailwindcss_postcss.isPureLocalCssImportWrapper)(currentRawSource)) return { result: new ConcatSource(require_generator.removeTailwindSourceDirectives(require_v4_generation_core.stripBundlerGeneratedCssMarkers(currentRawSource), { importFallback: true })) };
const fallbackGeneratorRuntimeSet = getGeneratorRuntimeSet();
const hasExplicitTailwindV4SourceCss = sourceCss !== void 0 && (require_generator.hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || sourceCss.includes("@config"));
const currentAssetHasTailwindDirectives = require_generator.hasTailwindRootDirectives(generatorRawSource, { importFallback: true }) || require_generator.hasTailwindSourceDirectives(generatorRawSource, { importFallback: true }) || require_generator.hasTailwindApplyDirective(generatorRawSource);
const shouldForceTailwindV4Generation = hasConfiguredTailwindV4SourceRoots() && (configuredMainCssEntryFiles.length > 0 && sourceFile !== void 0 || currentAssetHasTailwindDirectives || hasExplicitTailwindV4SourceCss);
const shouldSkipUnmatchedMainCssGeneration = !isWebGeneratorTarget && cssHandlerOptions.isMainChunk && sourceFile === void 0 && configuredMainCssEntryFiles.length > 0 && !currentAssetHasTailwindDirectives;
const shouldSkipPlainNonMainCssGeneration = !cssHandlerOptions.isMainChunk && sourceCss !== void 0 && !hasExplicitSourceCssForCurrentAsset && !hasExplicitTailwindV4SourceCss && !currentAssetHasTailwindDirectives;
const shouldMergeFallbackGeneratorRuntime = cssHandlerOptions.isMainChunk || currentAssetHasTailwindDirectives || hasExplicitSourceCssForCurrentAsset;
const scopedFallbackGeneratorRuntimeSet = hasExplicitTailwindV4SourceCss || !shouldMergeFallbackGeneratorRuntime ? /* @__PURE__ */ new Set() : fallbackGeneratorRuntimeSet;
const resolvedScopedGeneratorRuntimeSet = await require_source_candidate_scan_signature.createScopedGeneratorRuntime({
cssHandlerOptions,
fallbackRuntime: scopedFallbackGeneratorRuntimeSet,
getSourceCandidatesForEntries: webpackSourceCandidates?.getSourceCandidatesForEntries,
majorVersion: runtimeState.tailwindRuntime.majorVersion,
outputFile: file,
rawSource: sourceFile ? cssSources.get(node_path.default.resolve(sourceFile))?.css ?? generatorRawSource : generatorRawSource,
shouldExcludeSubpackageSourceCandidates: () => false,
sourceFile: sourceFile ?? file,
scopedSourceCandidateGetter: webpackSourceCandidates?.getSourceCandidatesForEntries
});
const scopedGeneratorRuntimeSet = !hasExplicitTailwindV4SourceCss && resolvedScopedGeneratorRuntimeSet !== scopedFallbackGeneratorRuntimeSet && shouldMergeFallbackGeneratorRuntime ? /* @__PURE__ */ new Set([...fallbackGeneratorRuntimeSet, ...resolvedScopedGeneratorRuntimeSet]) : resolvedScopedGeneratorRuntimeSet;
const generatorCssSources = require_pipeline_helpers.normalizeWebpackGeneratorCssSources(cssHandlerOptions.sourceOptions?.cssSources);
const scopedGeneratorCompilerOptions = require_pipeline_helpers.scopeWebpackGeneratorOptionsToCssSource(compilerOptions, sourceFile, { disableUnmatchedCssEntries: !isWebGeneratorTarget && cssHandlerOptions.isMainChunk });
const generatorCssHandlerOptions = generatorCssSources === void 0 ? cssHandlerOptions : {
...cssHandlerOptions,
sourceOptions: {
...cssHandlerOptions.sourceOptions,
cssSources: generatorCssSources
}
};
const generatorOptions = {
opts: scopedGeneratorCompilerOptions,
runtimeState,
runtime: scopedGeneratorRuntimeSet,
rawSource: generatorRawSource,
forceGenerator: shouldForceTailwindV4Generation,
...require_pipeline_helpers.hasUsableWebpackGeneratorCssSources(generatorCssSources) ? { cssSources: generatorCssSources } : {},
...userRawSource === void 0 ? {} : { userRawSource: userRawSource.css },
...userRawSource?.processed === true ? { userRawSourceProcessed: true } : {},
file,
cssHandlerOptions: generatorCssHandlerOptions,
cssUserHandlerOptions: getCssUserHandlerOptions(file),
compilationChanges: scopeCompilationChanges,
frameworkPostcssOwner: compilerOptions,
cssStage: "framework-processed",
getSourceCandidatesForEntries: webpackSourceCandidates?.getSourceCandidatesForEntries,
sourceCandidates: scopedGeneratorRuntimeSet,
restoreLocalCssImports: false,
scope: compilationScope,
styleHandler: compilerOptions.styleHandler,
debug
};
let generated;
if (!shouldSkipUnmatchedMainCssGeneration && !shouldSkipPlainNonMainCssGeneration) try {
generated = await require_v4_generation_core.generateTailwindV4Css({
...generatorOptions,
outputFile: file
});
} catch (error) {
if (!require_pipeline_helpers.shouldFallbackToWebpackUserCssOnGeneratorError({
configuredMainCssEntryFilesLength: configuredMainCssEntryFiles.length,
generatorRawSource,
hasExplicitTailwindV4SourceCss
})) throw error;
debug("css generator skipped for plain webpack css asset: %s %O", file, error);
generated = void 0;
}
else debug("css generator skipped for plain webpack css asset: %s", file);
for (const dependency of generated?.dependencies ?? []) compilation.fileDependencies?.add?.(dependency);
return finalizeWebpackGeneratedCssResult({
ConcatSource,
compilerOptions,
cssHandlerOptions,
currentRawSource,
debug,
file,
finalizeCssAssetSource,
finalizeTracedCss,
generated,
generatorRawSource,
generatorRuntimeSet,
isWebGeneratorTarget,
runtimeState,
shouldPreserveExistingPreflight,
sourceCss,
sourceCssProcessed,
userRawSource
});
}
});
}, cssTaskFactories, "tasks.css");
}
//#endregion
//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/asset-emission-plan.ts
function applyWebpackAssetEmissionPlan(plan, options) {
for (const operation of plan.operations()) {
if (operation.kind === "delete") {
options.compilation.deleteAsset?.(operation.assetId);