weapp-tailwindcss 5.0.12 → 5.1.0

package/dist/{bundle-state-DU2ATDhw.js → source-candidate-scan-signature-2ybpptAK.js}

@@ -1,10 +1,12 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_precheck = require("./precheck-30zNPRlI.js");
-let node_module = require("node:module");
+const require_context = require("./context-BHxLe743.js");
+const require_tailwindcss = require("./tailwindcss-DHIYcqXT.js");
+const require_hmr_timing = require("./hmr-timing-CogqkFaF.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
+let node_module = require("node:module");
 let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
 let node_buffer = require("node:buffer");
 //#region src/bundlers/shared/module-graph.ts
@@ -80,10 +82,14 @@ function slash(p) {
 	return (0, _weapp_tailwindcss_shared.ensurePosix)(p);
 }
 const isWindows = node_process.default.platform === "win32";
-const cssLangRE = new RegExp(`\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`);
+const cssLangRE = new RegExp(`\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)`);
+const htmlLangRE = /\.html?(?:$|\?)/;
 function isCSSRequest(request) {
 	return cssLangRE.test(request) || isSourceStyleRequest(request);
 }
+function isHTMLRequest(request) {
+	return htmlLangRE.test(request);
+}
 function normalizePath(id) {
 	return node_path.default.posix.normalize(isWindows ? (0, _weapp_tailwindcss_shared.ensurePosix)(id) : id);
 }
@@ -119,9 +125,9 @@ function resolvePackageDir(name) {
 }
 //#endregion
 //#region src/bundlers/shared/generated-css-marker.ts
-const BUNDLER_GENERATED_CSS_MARKER_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/i;
-const BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/gi;
-const BUNDLER_GENERATED_CSS_MARKER_CAPTURE_RE = /\/\*!\s*weapp-tailwindcss (vite|webpack)-generated-css(?::([^\s*]+))?\s*\*\/\s*/gi;
+const BUNDLER_GENERATED_CSS_MARKER_RE = /\/\*!?\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?:\s*:\s*[^\s*]+)?\s*\*\/\s*/i;
+const BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE = /\/\*!?\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?:\s*:\s*[^\s*]+)?\s*\*\/\s*/gi;
+const BUNDLER_GENERATED_CSS_MARKER_CAPTURE_RE = /\/\*!?\s*weapp-tailwindcss (vite|webpack)-generated-css(?:\s*:\s*([^\s*]+))?\s*\*\/\s*/gi;
 function createBundlerGeneratedCssMarker(bundler, file) {
 	return `/*! weapp-tailwindcss ${bundler}-generated-css:${encodeURIComponent(file)} */`;
 }
@@ -150,6 +156,25 @@ function parseBundlerGeneratedCssMarkerBlocks(source) {
 	return blocks;
 }
 //#endregion
+//#region src/bundlers/shared/v4-generation-core.ts
+async function generateTailwindV4Css(options) {
+	const majorVersion = options.runtimeState.tailwindRuntime.majorVersion;
+	if (majorVersion !== 4) throw new Error("weapp-tailwindcss 生成管线仅支持 Tailwind CSS v4。");
+	const generated = await require_hmr_timing.generateCssByGenerator(options);
+	if (!generated) return;
+	return {
+		...generated,
+		classSet: generated.classSet,
+		dependencies: generated.dependencies,
+		metadata: {
+			file: options.file,
+			majorVersion,
+			outputFile: options.outputFile,
+			...generated.metadata ?? {}
+		}
+	};
+}
+//#endregion
 //#region src/bundlers/vite/bundle-entries.ts
 function readOutputEntry(entry) {
 	if (entry.output.type === "chunk") return entry.output.code;
@@ -203,10 +228,12 @@ const CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
 const CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
 const CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
 const CSS_WHITESPACE_RE = /\s+/g;
+const JS_RUNTIME_AFFECTING_TEXT_HINT_RE = /["'`/]/;
+const JS_INCOMPLETE_TRAILING_OPERATOR_RE = /(?:=>|[=+\-*%&|^!~?:,.({[\]])\s*$/;
 function createHtmlRuntimeAffectingSignature(source) {
 	try {
 		const parts = [];
-		const parser = new require_precheck.Parser({
+		const parser = new require_context.Parser({
 			onattribute(name, value) {
 				parts.push(`a:${name}=${value}`);
 			},
@@ -226,15 +253,16 @@ function createHtmlRuntimeAffectingSignature(source) {
 	}
 }
 function createJsRuntimeAffectingSignature(source) {
+	if (!JS_RUNTIME_AFFECTING_TEXT_HINT_RE.test(source) && !JS_INCOMPLETE_TRAILING_OPERATOR_RE.test(source)) return "";
 	try {
-		const ast = require_precheck.babelParse(source, {
-			cache: true,
+		const ast = require_context.babelParse(source, {
+			cache: false,
 			cacheKey: "vite-runtime-affecting:unambiguous",
 			plugins: ["jsx", "typescript"],
 			sourceType: "unambiguous"
 		});
 		const parts = [];
-		require_precheck.traverse(ast, {
+		require_context.traverse(ast, {
 			noScope: true,
 			StringLiteral(path) {
 				parts.push(`s:${path.node.value}`);
@@ -298,8 +326,8 @@ function readEntrySource(output) {
 	return output.source.toString();
 }
 function classifyBundleEntry(file, opts) {
+	if (opts.htmlMatcher(file) || isHTMLRequest(file)) return "html";
 	if (opts.cssMatcher(file) || isCSSRequest(file)) return "css";
-	if (opts.htmlMatcher(file)) return "html";
 	if (opts.jsMatcher(file) || opts.wxsMatcher(file)) return "js";
 	return "other";
 }
@@ -334,12 +362,12 @@ function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false, opti
 		sourceHashByFile.set(file, hash);
 		const previousHash = state.sourceHashByFile.get(file);
 		const changed = previousHash == null || previousHash !== hash;
-		const previousRuntimeAffectingSignature = state.runtimeAffectingSignatureByFile.get(file);
 		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
-		const canReuseRuntimeAffectingSignature = !changed && previousRuntimeAffectingSignature != null && previousRuntimeAffectingHash != null;
-		const runtimeAffectingSignature = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingSignature : createRuntimeAffectingSourceSignature(source, type);
-		const runtimeAffectingHash = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingHash : opts.cache.computeHash(runtimeAffectingSignature);
-		runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+		const runtimeAffectingHash = !changed && previousRuntimeAffectingHash != null ? previousRuntimeAffectingHash : (() => {
+			const runtimeAffectingSignature = createRuntimeAffectingSourceSignature(source, type);
+			runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+			return opts.cache.computeHash(runtimeAffectingSignature);
+		})();
 		runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
 		if (changed) changedByType[type].add(file);
 		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) runtimeAffectingChangedByType[type].add(file);
@@ -392,16 +420,158 @@ function invertLinkedByEntry(linkedByEntry) {
 	}
 	return dependentsByLinkedFile;
 }
+function replaceMapEntries(target, source) {
+	target.clear();
+	for (const [key, value] of source) target.set(key, value);
+	return target;
+}
+function mergeMapEntries(target, source) {
+	for (const [key, value] of source) target.set(key, value);
+	return target;
+}
 function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
 	const incremental = options.incremental === true;
 	state.iteration += 1;
-	state.sourceHashByFile = incremental ? new Map([...state.sourceHashByFile, ...snapshot.sourceHashByFile]) : snapshot.sourceHashByFile;
-	state.runtimeAffectingSignatureByFile = incremental ? new Map([...state.runtimeAffectingSignatureByFile, ...snapshot.runtimeAffectingSignatureByFile]) : snapshot.runtimeAffectingSignatureByFile;
-	state.runtimeAffectingHashByFile = incremental ? new Map([...state.runtimeAffectingHashByFile, ...snapshot.runtimeAffectingHashByFile]) : snapshot.runtimeAffectingHashByFile;
-	state.linkedByEntry = incremental ? new Map([...state.linkedByEntry, ...linkedByEntry]) : linkedByEntry;
+	state.sourceHashByFile = incremental ? mergeMapEntries(state.sourceHashByFile, snapshot.sourceHashByFile) : replaceMapEntries(state.sourceHashByFile, snapshot.sourceHashByFile);
+	state.runtimeAffectingSignatureByFile.clear();
+	state.runtimeAffectingHashByFile = incremental ? mergeMapEntries(state.runtimeAffectingHashByFile, snapshot.runtimeAffectingHashByFile) : replaceMapEntries(state.runtimeAffectingHashByFile, snapshot.runtimeAffectingHashByFile);
+	state.linkedByEntry = incremental ? mergeMapEntries(state.linkedByEntry, linkedByEntry) : replaceMapEntries(state.linkedByEntry, linkedByEntry);
 	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
 }
 //#endregion
+//#region src/bundlers/vite/generate-bundle/signatures.ts
+function summarizeStringDiff(previous, next) {
+	if (previous === next) return "same";
+	const previousLength = previous.length;
+	const nextLength = next.length;
+	const minLength = Math.min(previousLength, nextLength);
+	let prefixLength = 0;
+	while (prefixLength < minLength && previous.charCodeAt(prefixLength) === next.charCodeAt(prefixLength)) prefixLength += 1;
+	let previousSuffixCursor = previousLength - 1;
+	let nextSuffixCursor = nextLength - 1;
+	while (previousSuffixCursor >= prefixLength && nextSuffixCursor >= prefixLength && previous.charCodeAt(previousSuffixCursor) === next.charCodeAt(nextSuffixCursor)) {
+		previousSuffixCursor -= 1;
+		nextSuffixCursor -= 1;
+	}
+	const previousChangedLength = previousSuffixCursor >= prefixLength ? previousSuffixCursor - prefixLength + 1 : 0;
+	const nextChangedLength = nextSuffixCursor >= prefixLength ? nextSuffixCursor - prefixLength + 1 : 0;
+	return `changed@${prefixLength} old=${previousChangedLength} new=${nextChangedLength} len=${previousLength}->${nextLength}`;
+}
+function createLinkedImpactSignature(entry, linkedImpactsByEntry, sourceHashByFile) {
+	const changedLinkedFiles = linkedImpactsByEntry.get(entry);
+	if (!changedLinkedFiles || changedLinkedFiles.size === 0) return;
+	return [...changedLinkedFiles].sort().map((file) => {
+		return `${file}:${sourceHashByFile.get(file) ?? "missing"}`;
+	}).join(",");
+}
+function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
+	if (!linkedImpactSignature) return runtimeSignature;
+	return `${runtimeSignature}:linked:${linkedImpactSignature}`;
+}
+function createStableTextSignature(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function createCandidateSignature(candidates) {
+	if (candidates.size === 0) return "empty";
+	return createStableTextSignature([...candidates].sort().join("\n"));
+}
+function getSnapshotHash(snapshotMap, file, fallback) {
+	return snapshotMap.get(file) ?? fallback;
+}
+function hasRuntimeAffectingSourceChanges(changedByType) {
+	return changedByType.html.size > 0 || changedByType.js.size > 0;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/scoped-generator.ts
+function hasOwnSourceDirectives(rawSource) {
+	return rawSource.includes("@source") || rawSource.includes("@config");
+}
+function createLocalSourceEntries(sourceFile) {
+	return [{
+		base: node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, ""))),
+		negated: false,
+		pattern: "**/*"
+	}];
+}
+function intersectCandidates(first, second) {
+	const scoped = /* @__PURE__ */ new Set();
+	const [small, large] = first.size <= second.size ? [first, second] : [second, first];
+	for (const candidate of small) if (large.has(candidate)) scoped.add(candidate);
+	return scoped;
+}
+function resolveScopedSourceEntries(rawSource, sourceFile, resolvedEntries) {
+	if (!hasOwnSourceDirectives(rawSource)) return {
+		entries: resolvedEntries,
+		localEntries: void 0
+	};
+	const localEntries = createLocalSourceEntries(sourceFile);
+	if (!resolvedEntries || resolvedEntries.length === 0) return {
+		entries: localEntries,
+		localEntries: void 0
+	};
+	return {
+		entries: resolvedEntries,
+		localEntries
+	};
+}
+async function createScopedGeneratorCandidateSignature(rawSource, sourceFile, fallbackSignature, getSourceCandidatesForEntries, options = {}) {
+	if (!getSourceCandidatesForEntries || !hasOwnSourceDirectives(rawSource)) return fallbackSignature;
+	const { entries, localEntries } = resolveScopedSourceEntries(rawSource, sourceFile, (await require_tailwindcss.resolveTailwindV4EntriesFromCssCached(rawSource, node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, "")))))?.entries);
+	if (entries === void 0) return fallbackSignature;
+	const scopedCandidates = getSourceCandidatesForEntries(entries);
+	const scopedSignature = createCandidateSignature(localEntries ? intersectCandidates(scopedCandidates, getSourceCandidatesForEntries(localEntries)) : scopedCandidates);
+	return options.includeFallbackSignature === true ? `${scopedSignature}:${fallbackSignature}` : scopedSignature;
+}
+async function createScopedGeneratorRuntime(options) {
+	const { cssHandlerOptions, fallbackRuntime, getSourceCandidatesForEntries, outputFile, rawSource, shouldExcludeSubpackageSourceCandidates, sourceFile, scopedSourceCandidateGetter } = options;
+	if (getSourceCandidatesForEntries && rawSource && sourceFile) {
+		const { entries, localEntries } = resolveScopedSourceEntries(rawSource, sourceFile, (await require_tailwindcss.resolveTailwindV4EntriesFromCssCached(rawSource, node_path.default.dirname(node_path.default.resolve(sourceFile.replace(/[?#].*$/, "")))))?.entries);
+		if (entries !== void 0 && (entries.length > 0 || hasOwnSourceDirectives(rawSource))) {
+			const scopedCandidates = scopedSourceCandidateGetter?.(entries) ?? getSourceCandidatesForEntries(entries);
+			if (!localEntries) return scopedCandidates;
+			return intersectCandidates(scopedCandidates, scopedSourceCandidateGetter?.(localEntries) ?? getSourceCandidatesForEntries(localEntries));
+		}
+	}
+	const scopedCandidates = scopedSourceCandidateGetter?.(void 0);
+	if (scopedCandidates && (scopedCandidates.size > 0 || shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions))) return scopedCandidates;
+	if (!shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions)) return fallbackRuntime;
+	return fallbackRuntime;
+}
+//#endregion
+//#region src/bundlers/vite/source-candidate-scan-signature.ts
+function normalizeSignaturePath(value) {
+	return slash(node_path.default.resolve(value));
+}
+function serializeInlineCandidates(inlineCandidates) {
+	return {
+		excluded: [...inlineCandidates?.excluded ?? []].sort(),
+		included: [...inlineCandidates?.included ?? []].sort()
+	};
+}
+function serializeSourceEntries(entries) {
+	return (entries ?? []).map((entry) => ({
+		base: normalizeSignaturePath(entry.base),
+		negated: entry.negated,
+		pattern: entry.pattern
+	})).sort((a, b) => `${a.base}\0${a.pattern}\0${a.negated}`.localeCompare(`${b.base}\0${b.pattern}\0${b.negated}`));
+}
+function createSourceCandidateScanSignature(input) {
+	return JSON.stringify({
+		inlineCandidates: serializeInlineCandidates(input.inlineCandidates),
+		outDir: input.outDir ? normalizeSignaturePath(input.outDir) : void 0,
+		roots: input.roots.map((root) => ({
+			entries: serializeSourceEntries(root.entries),
+			root: normalizeSignaturePath(root.root)
+		})),
+		scanAllSources: input.scanAllSources ?? false
+	});
+}
+//#endregion
 Object.defineProperty(exports, "applyLinkedResults", {
 	enumerable: true,
 	get: function() {
@@ -414,6 +584,12 @@ Object.defineProperty(exports, "buildBundleSnapshot", {
 		return buildBundleSnapshot;
 	}
 });
+Object.defineProperty(exports, "classifyBundleEntry", {
+	enumerable: true,
+	get: function() {
+		return classifyBundleEntry;
+	}
+});
 Object.defineProperty(exports, "createBundleBuildState", {
 	enumerable: true,
 	get: function() {
@@ -432,30 +608,90 @@ Object.defineProperty(exports, "createBundlerGeneratedCssMarker", {
 		return createBundlerGeneratedCssMarker;
 	}
 });
+Object.defineProperty(exports, "createCandidateSignature", {
+	enumerable: true,
+	get: function() {
+		return createCandidateSignature;
+	}
+});
+Object.defineProperty(exports, "createJsHashSalt", {
+	enumerable: true,
+	get: function() {
+		return createJsHashSalt;
+	}
+});
+Object.defineProperty(exports, "createLinkedImpactSignature", {
+	enumerable: true,
+	get: function() {
+		return createLinkedImpactSignature;
+	}
+});
 Object.defineProperty(exports, "createRuntimeAffectingSourceSignature", {
 	enumerable: true,
 	get: function() {
 		return createRuntimeAffectingSourceSignature;
 	}
 });
+Object.defineProperty(exports, "createScopedGeneratorCandidateSignature", {
+	enumerable: true,
+	get: function() {
+		return createScopedGeneratorCandidateSignature;
+	}
+});
+Object.defineProperty(exports, "createScopedGeneratorRuntime", {
+	enumerable: true,
+	get: function() {
+		return createScopedGeneratorRuntime;
+	}
+});
+Object.defineProperty(exports, "createSourceCandidateScanSignature", {
+	enumerable: true,
+	get: function() {
+		return createSourceCandidateScanSignature;
+	}
+});
 Object.defineProperty(exports, "formatPostcssSourceMap", {
 	enumerable: true,
 	get: function() {
 		return formatPostcssSourceMap;
 	}
 });
+Object.defineProperty(exports, "generateTailwindV4Css", {
+	enumerable: true,
+	get: function() {
+		return generateTailwindV4Css;
+	}
+});
+Object.defineProperty(exports, "getSnapshotHash", {
+	enumerable: true,
+	get: function() {
+		return getSnapshotHash;
+	}
+});
 Object.defineProperty(exports, "hasBundlerGeneratedCssMarker", {
 	enumerable: true,
 	get: function() {
 		return hasBundlerGeneratedCssMarker;
 	}
 });
+Object.defineProperty(exports, "hasRuntimeAffectingSourceChanges", {
+	enumerable: true,
+	get: function() {
+		return hasRuntimeAffectingSourceChanges;
+	}
+});
 Object.defineProperty(exports, "isCSSRequest", {
 	enumerable: true,
 	get: function() {
 		return isCSSRequest;
 	}
 });
+Object.defineProperty(exports, "isHTMLRequest", {
+	enumerable: true,
+	get: function() {
+		return isHTMLRequest;
+	}
+});
 Object.defineProperty(exports, "isSourceStyleRequest", {
 	enumerable: true,
 	get: function() {
@@ -516,6 +752,12 @@ Object.defineProperty(exports, "stripRequestQuery", {
 		return stripRequestQuery;
 	}
 });
+Object.defineProperty(exports, "summarizeStringDiff", {
+	enumerable: true,
+	get: function() {
+		return summarizeStringDiff;
+	}
+});
 Object.defineProperty(exports, "toAbsoluteOutputPath", {
 	enumerable: true,
 	get: function() {