weapp-tailwindcss 5.0.0-next.2 → 5.0.0-next.20

package/dist/gulp.js

@@ -1,18 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_recorder = require("./recorder-gYSNLfOP.js");
-const require_generator_css = require("./generator-css-D3OdPRiS.js");
+const require_v3_engine = require("./v3-engine-5LoZUH-4.js");
+const require_incremental_runtime_class_set = require("./incremental-runtime-class-set-CJ0Pnsw2.js");
+const require_precheck = require("./precheck-BjEbVEpX.js");
+const require_tailwindcss = require("./tailwindcss-BhG7BtB-.js");
+const require_source_candidates = require("./source-candidates-gxijpPI3.js");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
 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_buffer = require("node:buffer");
-let node_fs = require("node:fs");
-node_fs = require_chunk.__toESM(node_fs);
 let node_stream = require("node:stream");
 node_stream = require_chunk.__toESM(node_stream);
 //#region src/bundlers/gulp/index.ts
-const debug = require_recorder.createDebug();
+const debug = require_v3_engine.createDebug();
 const Transform = node_stream.default.Transform;
 /**
 * @name weapp-tw-gulp
@@ -20,19 +23,18 @@ const Transform = node_stream.default.Transform;
 * @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
 */
 function createPlugins(options = {}) {
-	const opts = require_recorder.getCompilerContext(options);
-	const hasExplicitGeneratorOptions = options.generator !== void 0;
-	const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
-	const patchRecorderState = require_recorder.setupPatchRecorder(initialTwPatcher, opts.tailwindcssBasedir, {
-		source: "runtime",
-		cwd: opts.tailwindcssBasedir ?? node_process.default.cwd()
+	const hasInitialTailwindCssRoots = require_tailwindcss.hasConfiguredTailwindV4CssRoots(options);
+	const opts = require_precheck.getCompilerContext({
+		...options,
+		__internalDeferMissingCssEntriesWarning: true
 	});
+	const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
+	const readyPromise = require_precheck.createTailwindRuntimeReadyPromise(initialTwPatcher);
 	let runtimeSet = /* @__PURE__ */ new Set();
 	const runtimeState = {
 		twPatcher: initialTwPatcher,
-		patchPromise: patchRecorderState.patchPromise,
-		refreshTailwindcssPatcher,
-		onPatchCompleted: patchRecorderState.onPatchCompleted
+		readyPromise,
+		refreshTailwindcssPatcher
 	};
 	const defaultStyleHandlerOptionsCache = /* @__PURE__ */ new Map();
 	let cachedDefaultTemplateHandlerOptions;
@@ -47,20 +49,138 @@ function createPlugins(options = {}) {
 		".jsx"
 	];
 	let runtimeSetInitialized = false;
-	async function refreshRuntimeState(force) {
-		await require_recorder.refreshTailwindRuntimeState(runtimeState, force);
-	}
-	async function refreshRuntimeSet(force = false) {
-		if (!force && runtimeSetInitialized) return runtimeSet;
-		runtimeSet = await require_recorder.ensureRuntimeClassSet(runtimeState, {
-			forceRefresh: force,
-			forceCollect: force,
-			clearCache: force,
+	let runtimeSetDirty = false;
+	const runtimeSourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeSourcesByFile = /* @__PURE__ */ new Map();
+	let cachedGulpSourceCandidates;
+	let cachedGulpSourceCandidateSignature;
+	const bundleRuntimeClassSetManager = options.__internalGulpRuntimeClassSetManager ?? require_incremental_runtime_class_set.createBundleRuntimeClassSetManager();
+	async function refreshRuntimeSet(options = false) {
+		const normalizedOptions = typeof options === "boolean" ? {
+			forceRefresh: options,
+			forceCollect: options,
+			clearCache: options
+		} : options;
+		const forceRefresh = normalizedOptions.forceRefresh === true;
+		const shouldForceCollect = normalizedOptions.forceCollect === true || runtimeSetDirty;
+		const clearCache = normalizedOptions.clearCache === true || runtimeSetDirty;
+		if (!forceRefresh && !shouldForceCollect && runtimeSetInitialized) return runtimeSet;
+		runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, {
+			forceRefresh,
+			forceCollect: shouldForceCollect,
+			clearCache,
 			allowEmpty: false
 		});
 		runtimeSetInitialized = true;
+		runtimeSetDirty = false;
 		return runtimeSet;
 	}
+	function createRuntimeSnapshot(changedFiles) {
+		const runtimeAffectingChangedByType = {
+			html: /* @__PURE__ */ new Set(),
+			js: /* @__PURE__ */ new Set(),
+			css: /* @__PURE__ */ new Set(),
+			other: /* @__PURE__ */ new Set()
+		};
+		for (const file of changedFiles) {
+			const entry = runtimeSourcesByFile.get(file);
+			if (entry) runtimeAffectingChangedByType[entry.type].add(file);
+		}
+		return {
+			entries: [...runtimeSourcesByFile.entries()].map(([file, entry]) => ({
+				file,
+				output: {
+					fileName: file,
+					source: entry.source,
+					type: "asset"
+				},
+				source: entry.source,
+				type: entry.type
+			})),
+			jsEntries: /* @__PURE__ */ new Map(),
+			sourceHashByFile: /* @__PURE__ */ new Map(),
+			runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+			runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+			changedByType: {
+				html: /* @__PURE__ */ new Set(),
+				js: /* @__PURE__ */ new Set(),
+				css: /* @__PURE__ */ new Set(),
+				other: /* @__PURE__ */ new Set()
+			},
+			runtimeAffectingChangedByType,
+			processFiles: {
+				html: /* @__PURE__ */ new Set(),
+				js: /* @__PURE__ */ new Set(),
+				css: /* @__PURE__ */ new Set()
+			},
+			linkedImpactsByEntry: /* @__PURE__ */ new Map()
+		};
+	}
+	async function refreshRuntimeSetForSource(file, rawSource, type) {
+		const filename = node_path.default.resolve(file.path);
+		const hash = cache.computeHash(rawSource);
+		const changed = runtimeSourceHashByFile.get(filename) !== hash;
+		runtimeSourceHashByFile.set(filename, hash);
+		runtimeSourcesByFile.set(filename, {
+			source: rawSource,
+			type
+		});
+		if (!changed && runtimeSetInitialized) return runtimeSet;
+		if (runtimeState.twPatcher.majorVersion === 4 && !runtimeSetDirty) try {
+			runtimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, createRuntimeSnapshot([filename]));
+			runtimeSetInitialized = true;
+			return runtimeSet;
+		} catch (error) {
+			debug("gulp incremental runtime set sync failed, fallback to collect: %O", error);
+			await bundleRuntimeClassSetManager.reset();
+		}
+		return refreshRuntimeSet({ forceCollect: true });
+	}
+	async function refreshGulpSourceCandidates(forceRefresh = false) {
+		if (runtimeState.twPatcher.majorVersion !== 3) return /* @__PURE__ */ new Set();
+		const root = opts.tailwindcssBasedir ?? node_process.default.cwd();
+		const sourceScan = await require_v3_engine.resolveViteSourceScanEntries(opts, runtimeState.twPatcher, { root });
+		const nextSignature = cache.computeHash(JSON.stringify({
+			root,
+			entries: sourceScan?.entries,
+			inlineCandidates: sourceScan?.inlineCandidates ? {
+				included: [...sourceScan.inlineCandidates.included].sort(),
+				excluded: [...sourceScan.inlineCandidates.excluded].sort()
+			} : void 0,
+			explicit: sourceScan?.explicit ?? false,
+			dependencies: [...sourceScan?.dependencies ?? []].sort()
+		}));
+		if (!forceRefresh && cachedGulpSourceCandidateSignature === nextSignature && cachedGulpSourceCandidates) return cachedGulpSourceCandidates;
+		const collector = require_source_candidates.createSourceCandidateCollector();
+		await collector.scanRoot({
+			entries: sourceScan?.entries,
+			root
+		});
+		collector.syncInline(sourceScan?.inlineCandidates);
+		cachedGulpSourceCandidateSignature = nextSignature;
+		cachedGulpSourceCandidates = sourceScan?.entries ? collector.valuesForEntries(sourceScan.entries) : collector.values();
+		return cachedGulpSourceCandidates;
+	}
+	function createRuntimeSetHash(rawSource, nextRuntimeSet) {
+		return cache.computeHash([
+			rawSource,
+			require_v3_engine.getRuntimeClassSetSignature(runtimeState.twPatcher),
+			[...nextRuntimeSet].sort().join("\n")
+		].join("\n\n"));
+	}
+	async function registerAutoCssSource(file, rawSource) {
+		if (hasInitialTailwindCssRoots || (runtimeState.twPatcher.majorVersion ?? 0) < 4 || !file.path || !require_incremental_runtime_class_set.hasTailwindRootDirectives(rawSource)) return false;
+		const sourceCss = require_incremental_runtime_class_set.normalizeTailwindSourceForGenerator(rawSource, { importFallback: true });
+		if (!require_tailwindcss.upsertTailwindV4CssSource(opts, {
+			file: node_path.default.resolve(file.path),
+			css: sourceCss
+		})) return false;
+		runtimeSetInitialized = false;
+		runtimeSetDirty = true;
+		await bundleRuntimeClassSetManager.reset();
+		debug("detected tailwindcss v4 css source from gulp css file: %s", file.path);
+		return true;
+	}
 	function resolveWithExtensions(base) {
 		for (const ext of MODULE_EXTENSIONS) {
 			const candidate = `${base}${ext}`;
@@ -107,12 +227,14 @@ function createPlugins(options = {}) {
 		if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createModuleGraphOptionsFor();
 		return cachedDefaultModuleGraphOptions;
 	}
-	function createVinylTransform(handler) {
+	function createVinylTransform(phase, handler) {
 		return new Transform({
 			objectMode: true,
 			async transform(file, _encoding, callback) {
+				const hmrTimingStartedAt = performance.now();
 				try {
 					await handler(file);
+					require_incremental_runtime_class_set.emitHmrTiming("gulp", phase, performance.now() - hmrTimingStartedAt, { file: file.relative || node_path.default.basename(file.path) });
 					callback(null, file);
 				} catch (error) {
 					callback(error, file);
@@ -125,12 +247,12 @@ function createPlugins(options = {}) {
 		if (!options || Object.keys(options).length === 0) {
 			let cached = defaultStyleHandlerOptionsCache.get(majorVersion);
 			if (!cached) {
-				cached = { majorVersion: runtimeState.twPatcher.majorVersion };
+				cached = runtimeState.twPatcher.majorVersion === void 0 ? {} : { majorVersion: runtimeState.twPatcher.majorVersion };
 				defaultStyleHandlerOptionsCache.set(majorVersion, cached);
 			}
 			return cached;
 		}
-		return {
+		return runtimeState.twPatcher.majorVersion === void 0 ? { ...options } : {
 			majorVersion: runtimeState.twPatcher.majorVersion,
 			...options
 		};
@@ -165,15 +287,28 @@ function createPlugins(options = {}) {
 			...options
 		};
 	}
-	const transformWxss = (options = {}) => createVinylTransform(async (file) => {
+	const transformWxss = (options = {}) => createVinylTransform("css", async (file) => {
 		if (!file.contents) return;
-		await refreshRuntimeState(true);
-		await runtimeState.patchPromise;
 		const rawSource = file.contents.toString();
-		await require_generator_css.processCachedTask({
+		const cssSourceChanged = await registerAutoCssSource(file, rawSource);
+		const isMainChunk = opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType);
+		const shouldUseGenerator = runtimeState.twPatcher.majorVersion !== 3 || require_incremental_runtime_class_set.hasTailwindRootDirectives(rawSource);
+		let nextRuntimeSet = await refreshRuntimeSet({
+			forceRefresh: cssSourceChanged,
+			forceCollect: cssSourceChanged || runtimeState.twPatcher.majorVersion !== 4 && isMainChunk,
+			clearCache: cssSourceChanged
+		});
+		if (runtimeState.twPatcher.majorVersion === 3 && isMainChunk && shouldUseGenerator) {
+			const sourceCandidates = await refreshGulpSourceCandidates(cssSourceChanged);
+			if (sourceCandidates.size > 0) {
+				nextRuntimeSet = new Set([...nextRuntimeSet, ...sourceCandidates]);
+				runtimeSet = nextRuntimeSet;
+			}
+		}
+		await require_incremental_runtime_class_set.processCachedTask({
 			cache,
 			cacheKey: file.path,
-			rawSource,
+			hash: createRuntimeSetHash(rawSource, nextRuntimeSet),
 			applyResult(source) {
 				file.contents = node_buffer.Buffer.from(source);
 			},
@@ -181,12 +316,12 @@ function createPlugins(options = {}) {
 				debug("css cache hit: %s", file.path);
 			},
 			async transform() {
-				await runtimeState.patchPromise;
+				await runtimeState.readyPromise;
 				const cssHandlerOptions = resolveWxssFileHandlerOptions(file, options);
-				const css = (hasExplicitGeneratorOptions ? await require_generator_css.generateCssByGenerator({
+				const css = (shouldUseGenerator ? await require_incremental_runtime_class_set.generateCssByGenerator({
 					opts,
 					runtimeState,
-					runtime: await refreshRuntimeSet(false),
+					runtime: nextRuntimeSet,
 					rawSource,
 					file: file.path,
 					cssHandlerOptions,
@@ -199,24 +334,24 @@ function createPlugins(options = {}) {
 			}
 		});
 	});
-	const transformJs = (options = {}) => createVinylTransform(async (file) => {
+	const transformJs = (options = {}) => createVinylTransform("js", async (file) => {
 		if (!file.contents) return;
-		await refreshRuntimeSet(false);
-		await runtimeState.patchPromise;
 		const filename = node_path.default.resolve(file.path);
+		const rawSource = file.contents.toString();
+		await refreshRuntimeSetForSource(file, rawSource, "js");
+		await runtimeState.readyPromise;
 		const moduleGraph = resolveModuleGraphOptions(options.moduleGraph);
 		const handlerOptions = {
 			...options,
 			filename,
 			moduleGraph,
-			tailwindcssMajorVersion: runtimeState.twPatcher.majorVersion,
 			babelParserOptions: {
 				...options?.babelParserOptions ?? {},
 				sourceFilename: filename
 			}
 		};
-		const rawSource = file.contents.toString();
-		await require_generator_css.processCachedTask({
+		if (runtimeState.twPatcher.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.twPatcher.majorVersion;
+		await require_incremental_runtime_class_set.processCachedTask({
 			cache,
 			cacheKey: file.path,
 			rawSource,
@@ -227,21 +362,24 @@ function createPlugins(options = {}) {
 				debug("js cache hit: %s", file.path);
 			},
 			async transform() {
-				await runtimeState.patchPromise;
+				await runtimeState.readyPromise;
 				const currentSource = file.contents?.toString() ?? rawSource;
-				if (require_recorder.shouldSkipJsTransform(currentSource, handlerOptions)) return { result: currentSource };
+				if (require_precheck.shouldSkipJsTransform(currentSource, {
+					...handlerOptions,
+					classNameSet: runtimeSet
+				})) return { result: currentSource };
 				const { code } = await jsHandler(currentSource, runtimeSet, handlerOptions);
 				debug("js handle: %s", file.path);
 				return { result: code };
 			}
 		});
 	});
-	const transformWxml = (options = {}) => createVinylTransform(async (file) => {
+	const transformWxml = (options = {}) => createVinylTransform("html", async (file) => {
 		if (!file.contents) return;
-		await refreshRuntimeSet(false);
-		await runtimeState.patchPromise;
 		const rawSource = file.contents.toString();
-		await require_generator_css.processCachedTask({
+		await refreshRuntimeSetForSource(file, rawSource, "html");
+		await runtimeState.readyPromise;
+		await require_incremental_runtime_class_set.processCachedTask({
 			cache,
 			cacheKey: file.path,
 			rawSource,
@@ -252,7 +390,7 @@ function createPlugins(options = {}) {
 				debug("html cache hit: %s", file.path);
 			},
 			async transform() {
-				await runtimeState.patchPromise;
+				await runtimeState.readyPromise;
 				const code = await templateHandler(rawSource, resolveWxmlHandlerOptions(options));
 				debug("html handle: %s", file.path);
 				return { result: code };