weapp-tailwindcss 5.0.6 → 5.0.8

package/dist/gulp-B22YSGU_.mjs

@@ -0,0 +1,463 @@
+import { D as normalizeTailwindConfigDirectives, T as hasTailwindRootDirectives, k as normalizeTailwindSourceForGenerator, l as getRuntimeClassSetSignature, lt as createDebug, m as resolveViteSourceScanEntries } from "./v3-engine-ArQVHEau.mjs";
+import { n as getCompilerContext, t as shouldSkipJsTransform, v as createTailwindRuntimeReadyPromise, y as ensureRuntimeClassSet } from "./precheck-CcxTR7E_.mjs";
+import { c as hasConfiguredTailwindV4CssRoots, l as upsertTailwindV4CssSource } from "./tailwindcss-0DaftXcU.mjs";
+import { a as createTailwindV3DefaultExtractor, g as createCssTokenSourceMap, h as createCssSourceTraceCacheSignature, m as annotateCssSourceTrace, n as emitHmrTiming, o as createBundleRuntimeClassSetManager, r as createSourceCandidateCollector, s as generateCssByGenerator, v as processCachedTask } from "./hmr-timing-DK-mine6.mjs";
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import stream from "node:stream";
+//#region src/bundlers/gulp/module-graph.ts
+const MODULE_EXTENSIONS = [
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".jsx"
+];
+function resolveWithExtensions(base) {
+	for (const ext of MODULE_EXTENSIONS) {
+		const candidate = `${base}${ext}`;
+		try {
+			if (fs.statSync(candidate).isFile()) return candidate;
+		} catch {
+			continue;
+		}
+	}
+}
+function resolveLocalModuleCandidate(base) {
+	try {
+		const stat = fs.statSync(base);
+		if (stat.isFile()) return base;
+		if (stat.isDirectory()) {
+			const resolvedIndex = resolveWithExtensions(path.join(base, "index"));
+			if (resolvedIndex) return resolvedIndex;
+		}
+	} catch {}
+	if (!path.extname(base)) return resolveWithExtensions(base);
+}
+function createGulpModuleGraphOptions(opts) {
+	return {
+		resolve(specifier, importer) {
+			if (!specifier) return;
+			if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return;
+			return resolveLocalModuleCandidate(path.resolve(path.dirname(importer), specifier));
+		},
+		load(id) {
+			try {
+				return fs.readFileSync(id, "utf8");
+			} catch {
+				return;
+			}
+		},
+		filter(id) {
+			const relative = path.relative(process.cwd(), id);
+			return opts.jsMatcher(relative) || opts.wxsMatcher(relative);
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/gulp/runtime-snapshot.ts
+function createGulpRuntimeSnapshot(runtimeSourcesByFile, 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(),
+		hasOmittedKnownFiles: false,
+		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()
+	};
+}
+//#endregion
+//#region src/bundlers/gulp/vinyl-transform.ts
+const Transform = stream.Transform;
+function createVinylTransform(phase, handler) {
+	return new Transform({
+		objectMode: true,
+		async transform(file, _encoding, callback) {
+			const hmrTimingStartedAt = performance.now();
+			try {
+				await handler(file);
+				emitHmrTiming("gulp", phase, performance.now() - hmrTimingStartedAt, { file: file.relative || path.basename(file.path) });
+				callback(null, file);
+			} catch (error) {
+				callback(error, file);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/bundlers/gulp/index.ts
+const debug = createDebug();
+/**
+* @name weapp-tw-gulp
+* @description gulp版本weapp-tw插件
+* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+*/
+function createPlugins(options = {}) {
+	const hasInitialTailwindCssRoots = hasConfiguredTailwindV4CssRoots(options);
+	const opts = getCompilerContext({
+		...options,
+		__internalDeferMissingCssEntriesWarning: true
+	});
+	const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
+	const readyPromise = createTailwindRuntimeReadyPromise(initialTwPatcher);
+	let runtimeSet = /* @__PURE__ */ new Set();
+	const runtimeState = {
+		twPatcher: initialTwPatcher,
+		readyPromise,
+		refreshTailwindcssPatcher
+	};
+	const defaultStyleHandlerOptionsCache = /* @__PURE__ */ new Map();
+	let cachedDefaultTemplateHandlerOptions;
+	let cachedDefaultTemplateRuntimeSet;
+	let cachedDefaultModuleGraphOptions;
+	let cachedGulpSourceCandidateGetter;
+	let cachedGulpSourceCandidateSourceGetter;
+	let runtimeSetInitialized = false;
+	let runtimeSetDirty = false;
+	const runtimeSourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeSourcesByFile = /* @__PURE__ */ new Map();
+	let cachedGulpSourceCandidates;
+	let cachedGulpSourceCandidateSignature;
+	const sourceCandidateExtractor = initialTwPatcher.majorVersion === 3 ? createTailwindV3DefaultExtractor() : void 0;
+	const bundleRuntimeClassSetManager = options.__internalGulpRuntimeClassSetManager ?? createBundleRuntimeClassSetManager();
+	function invalidateGulpSourceCandidates() {
+		cachedGulpSourceCandidates = void 0;
+		cachedGulpSourceCandidateSignature = void 0;
+		cachedGulpSourceCandidateGetter = void 0;
+		cachedGulpSourceCandidateSourceGetter = void 0;
+	}
+	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 ensureRuntimeClassSet(runtimeState, {
+			forceRefresh,
+			forceCollect: shouldForceCollect,
+			clearCache,
+			allowEmpty: false
+		});
+		runtimeSetInitialized = true;
+		runtimeSetDirty = false;
+		return runtimeSet;
+	}
+	async function refreshRuntimeSetForSource(file, rawSource, type) {
+		const filename = path.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 && runtimeState.twPatcher.majorVersion === 4) invalidateGulpSourceCandidates();
+		if (!changed && runtimeSetInitialized) return runtimeSet;
+		if (runtimeState.twPatcher.majorVersion === 4 && !runtimeSetDirty) try {
+			runtimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, createGulpRuntimeSnapshot(runtimeSourcesByFile, [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 ?? process.cwd();
+		const sourceScan = await 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 = createSourceCandidateCollector({
+			bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+			extractor: sourceCandidateExtractor
+		});
+		await collector.scanRoot({
+			entries: sourceScan?.entries,
+			root
+		});
+		collector.syncInline(sourceScan?.inlineCandidates);
+		cachedGulpSourceCandidateSignature = nextSignature;
+		cachedGulpSourceCandidateGetter = (entries) => collector.valuesForEntries(entries);
+		cachedGulpSourceCandidateSourceGetter = (entries) => collector.sourcesForEntries(entries);
+		cachedGulpSourceCandidates = sourceScan?.entries ? collector.valuesForEntries(sourceScan.entries) : collector.values();
+		return cachedGulpSourceCandidates;
+	}
+	async function refreshGulpV4SourceCandidates(forceRefresh = false) {
+		if (runtimeState.twPatcher.majorVersion !== 4) {
+			cachedGulpSourceCandidateGetter = void 0;
+			cachedGulpSourceCandidateSourceGetter = void 0;
+			return;
+		}
+		const root = opts.tailwindcssBasedir ?? process.cwd();
+		const sourceScan = await 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 && cachedGulpSourceCandidateGetter) return cachedGulpSourceCandidateGetter;
+		const collector = createSourceCandidateCollector({ bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues });
+		await collector.scanRoot({
+			entries: sourceScan?.entries,
+			explicit: sourceScan?.explicit,
+			root
+		});
+		collector.syncInline(sourceScan?.inlineCandidates);
+		cachedGulpSourceCandidateSignature = nextSignature;
+		cachedGulpSourceCandidateGetter = (entries) => collector.valuesForEntries(entries);
+		cachedGulpSourceCandidateSourceGetter = (entries) => collector.sourcesForEntries(entries);
+		return cachedGulpSourceCandidateGetter;
+	}
+	function createRuntimeSetHash(rawSource, nextRuntimeSet, sourceTraceSignature) {
+		return cache.computeHash([
+			rawSource,
+			getRuntimeClassSetSignature(runtimeState.twPatcher),
+			[...nextRuntimeSet].sort().join("\n"),
+			sourceTraceSignature ?? "css-source-trace:0"
+		].join("\n\n"));
+	}
+	async function registerAutoCssSource(file, rawSource) {
+		if (hasInitialTailwindCssRoots || (runtimeState.twPatcher.majorVersion ?? 0) < 4 || !file.path || !hasTailwindRootDirectives(rawSource)) return false;
+		const sourceFile = path.resolve(file.path);
+		const sourceCss = normalizeTailwindSourceForGenerator(normalizeTailwindConfigDirectives(rawSource, path.dirname(sourceFile)), { importFallback: true });
+		if (!upsertTailwindV4CssSource(opts, {
+			file: sourceFile,
+			base: path.dirname(sourceFile),
+			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 resolveModuleGraphOptions(moduleGraph) {
+		if (moduleGraph) return moduleGraph;
+		if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createGulpModuleGraphOptions(opts);
+		return cachedDefaultModuleGraphOptions;
+	}
+	function resolveWxssHandlerOptions(options) {
+		const majorVersion = runtimeState.twPatcher.majorVersion ?? "unknown";
+		if (!options || Object.keys(options).length === 0) {
+			let cached = defaultStyleHandlerOptionsCache.get(majorVersion);
+			if (!cached) {
+				cached = runtimeState.twPatcher.majorVersion === void 0 ? {} : { majorVersion: runtimeState.twPatcher.majorVersion };
+				defaultStyleHandlerOptionsCache.set(majorVersion, cached);
+			}
+			return cached;
+		}
+		return runtimeState.twPatcher.majorVersion === void 0 ? { ...options } : {
+			majorVersion: runtimeState.twPatcher.majorVersion,
+			...options
+		};
+	}
+	function resolveGulpMatcherName(file) {
+		return (file.relative || path.basename(file.path)).replaceAll(path.sep, "/");
+	}
+	function resolveWxssFileHandlerOptions(file, options) {
+		const resolved = resolveWxssHandlerOptions(options);
+		if (resolved.isMainChunk !== void 0) return resolved;
+		return {
+			...resolved,
+			isMainChunk: opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType)
+		};
+	}
+	function resolveWxssUserHandlerOptions(options) {
+		return {
+			...resolveWxssHandlerOptions(options),
+			isMainChunk: false
+		};
+	}
+	function resolveWxmlHandlerOptions(options) {
+		if (!options || Object.keys(options).length === 0) {
+			if (cachedDefaultTemplateRuntimeSet !== runtimeSet || !cachedDefaultTemplateHandlerOptions) {
+				cachedDefaultTemplateRuntimeSet = runtimeSet;
+				cachedDefaultTemplateHandlerOptions = { runtimeSet };
+			}
+			return cachedDefaultTemplateHandlerOptions;
+		}
+		return {
+			runtimeSet,
+			...options
+		};
+	}
+	const transformWxss = (options = {}) => createVinylTransform("css", async (file) => {
+		if (!file.contents) return;
+		const rawSource = file.contents.toString();
+		const cssSourceChanged = await registerAutoCssSource(file, rawSource);
+		const isMainChunk = opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType);
+		const shouldUseGenerator = runtimeState.twPatcher.majorVersion !== 3 || hasTailwindRootDirectives(rawSource);
+		const gulpV4SourceCandidates = shouldUseGenerator && runtimeState.twPatcher.majorVersion === 4 ? await refreshGulpV4SourceCandidates(cssSourceChanged) : void 0;
+		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;
+			}
+		}
+		const sourceTraceTokenSources = cachedGulpSourceCandidateSourceGetter ? createCssTokenSourceMap(cachedGulpSourceCandidateSourceGetter(void 0), opts) : void 0;
+		const sourceTraceSignature = createCssSourceTraceCacheSignature(sourceTraceTokenSources, opts);
+		await processCachedTask({
+			cache,
+			cacheKey: file.path,
+			hash: createRuntimeSetHash(rawSource, nextRuntimeSet, sourceTraceSignature),
+			applyResult(source) {
+				file.contents = Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("css cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const cssHandlerOptions = resolveWxssFileHandlerOptions(file, options);
+				const css = annotateCssSourceTrace((shouldUseGenerator ? await generateCssByGenerator({
+					opts,
+					runtimeState,
+					runtime: nextRuntimeSet,
+					rawSource,
+					file: file.path,
+					cssHandlerOptions,
+					cssUserHandlerOptions: resolveWxssUserHandlerOptions(options),
+					getSourceCandidatesForEntries: gulpV4SourceCandidates,
+					styleHandler,
+					debug
+				}) : void 0)?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css, {
+					opts,
+					tokenSources: sourceTraceTokenSources
+				});
+				debug("css handle: %s", file.path);
+				return { result: css };
+			}
+		});
+	});
+	const transformJs = (options = {}) => createVinylTransform("js", async (file) => {
+		if (!file.contents) return;
+		const filename = path.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,
+			babelParserOptions: {
+				...options?.babelParserOptions ?? {},
+				sourceFilename: filename
+			}
+		};
+		if (runtimeState.twPatcher.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.twPatcher.majorVersion;
+		await processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("js cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const currentSource = file.contents?.toString() ?? rawSource;
+				if (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("html", async (file) => {
+		if (!file.contents) return;
+		const rawSource = file.contents.toString();
+		await refreshRuntimeSetForSource(file, rawSource, "html");
+		await runtimeState.readyPromise;
+		await processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("html cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const code = await templateHandler(rawSource, resolveWxmlHandlerOptions(options));
+				debug("html handle: %s", file.path);
+				return { result: code };
+			}
+		});
+	});
+	return {
+		transformWxss,
+		transformWxml,
+		transformJs
+	};
+}
+//#endregion
+export { createPlugins as t };