weapp-tailwindcss 5.0.5 → 5.0.7

package/dist/gulp.mjs

@@ -1,407 +1,2 @@
-import { D as normalizeTailwindConfigDirectives, T as hasTailwindRootDirectives, _ as resolveViteSourceScanEntries, k as normalizeTailwindSourceForGenerator, l as getRuntimeClassSetSignature, lt as createDebug } from "./v3-engine-Cczrkzqt.mjs";
-import { n as getCompilerContext, t as shouldSkipJsTransform, v as createTailwindRuntimeReadyPromise, y as ensureRuntimeClassSet } from "./precheck-Bsn_LMmo.mjs";
-import { c as hasConfiguredTailwindV4CssRoots, l as upsertTailwindV4CssSource } from "./tailwindcss-AWaPVF2B.mjs";
-import { i as generateCssByGenerator, r as emitHmrTiming, s as processCachedTask, t as createBundleRuntimeClassSetManager } from "./incremental-runtime-class-set-xf49kky6.mjs";
-import { n as createTailwindV3DefaultExtractor, t as createSourceCandidateCollector } from "./source-candidates-BsWYoIPN.mjs";
-import fs from "node:fs";
-import process from "node:process";
-import path from "node:path";
-import { Buffer } from "node:buffer";
-import stream from "node:stream";
-//#region src/bundlers/gulp/index.ts
-const debug = createDebug();
-const Transform = stream.Transform;
-/**
-* @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;
-	const MODULE_EXTENSIONS = [
-		".js",
-		".mjs",
-		".cjs",
-		".ts",
-		".tsx",
-		".jsx"
-	];
-	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();
-	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;
-	}
-	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 = 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 && 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 ?? 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;
-		cachedGulpSourceCandidates = sourceScan?.entries ? collector.valuesForEntries(sourceScan.entries) : collector.values();
-		return cachedGulpSourceCandidates;
-	}
-	function createRuntimeSetHash(rawSource, nextRuntimeSet) {
-		return cache.computeHash([
-			rawSource,
-			getRuntimeClassSetSignature(runtimeState.twPatcher),
-			[...nextRuntimeSet].sort().join("\n")
-		].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 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 createModuleGraphOptionsFor() {
-		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);
-			}
-		};
-	}
-	function resolveModuleGraphOptions(moduleGraph) {
-		if (moduleGraph) return moduleGraph;
-		if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createModuleGraphOptionsFor();
-		return cachedDefaultModuleGraphOptions;
-	}
-	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);
-				}
-			}
-		});
-	}
-	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);
-		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 processCachedTask({
-			cache,
-			cacheKey: file.path,
-			hash: createRuntimeSetHash(rawSource, nextRuntimeSet),
-			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 = (shouldUseGenerator ? await generateCssByGenerator({
-					opts,
-					runtimeState,
-					runtime: nextRuntimeSet,
-					rawSource,
-					file: file.path,
-					cssHandlerOptions,
-					cssUserHandlerOptions: resolveWxssUserHandlerOptions(options),
-					styleHandler,
-					debug
-				}) : void 0)?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
-				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
+import { t as createPlugins } from "./gulp-oE-Byqk6.mjs";
 export { createPlugins as WeappTailwindcss, createPlugins, createPlugins as weappTailwindcss };