weapp-tailwindcss 4.12.0 → 5.0.0-next.10

package/dist/generator.d.ts

@@ -0,0 +1 @@
+export * from './generator/index'

package/dist/generator.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./chunk-8l464Juk.js");
+const require_generator = require("./generator-DKkhJbOg.js");
+let tailwindcss_patch = require("tailwindcss-patch");
+exports.createWeappTailwindcssGenerator = require_generator.createWeappTailwindcssGenerator;
+exports.createWeappTailwindcssGeneratorFromPatcher = require_generator.createWeappTailwindcssGeneratorFromPatcher;
+exports.normalizeWeappTailwindcssGeneratorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions;
+exports.resolveTailwindSourceFromPatcher = require_generator.resolveTailwindSourceFromPatcher;
+exports.resolveTailwindV3Source = require_generator.resolveTailwindV3Source;
+exports.resolveTailwindV3SourceFromPatcher = require_generator.resolveTailwindV3SourceFromPatcher;
+exports.resolveTailwindV3SourceOptionsFromPatcher = require_generator.resolveTailwindV3SourceOptionsFromPatcher;
+exports.resolveTailwindV4Source = require_generator.resolveTailwindV4Source;
+exports.resolveTailwindV4SourceFromPatchOptions = tailwindcss_patch.resolveTailwindV4SourceFromPatchOptions;
+exports.resolveTailwindV4SourceFromPatcher = require_generator.resolveTailwindV4SourceFromPatcher;
+exports.resolveTailwindV4SourceOptionsFromPatcher = require_generator.resolveTailwindV4SourceOptionsFromPatcher;
+exports.transformTailwindV3CssByTarget = require_generator.transformTailwindV3CssByTarget;
+exports.transformTailwindV3CssToWeapp = require_generator.transformTailwindV3CssToWeapp;
+exports.transformTailwindV4CssByTarget = require_generator.transformTailwindV4CssByTarget;
+exports.transformTailwindV4CssToWeapp = require_generator.transformTailwindV4CssToWeapp;

package/dist/generator.mjs

@@ -0,0 +1,2 @@
+import { _ as transformTailwindV3CssToWeapp, a as resolveTailwindV4Source, c as resolveTailwindV4SourceOptionsFromPatcher, g as transformTailwindV3CssByTarget, h as resolveTailwindV3SourceOptionsFromPatcher, i as normalizeWeappTailwindcssGeneratorOptions, l as transformTailwindV4CssByTarget, m as resolveTailwindV3SourceFromPatcher, n as createWeappTailwindcssGeneratorFromPatcher, o as resolveTailwindV4SourceFromPatchOptions, p as resolveTailwindV3Source, r as resolveTailwindSourceFromPatcher, s as resolveTailwindV4SourceFromPatcher, t as createWeappTailwindcssGenerator, u as transformTailwindV4CssToWeapp } from "./generator-UBmfduYg.mjs";
+export { createWeappTailwindcssGenerator, createWeappTailwindcssGeneratorFromPatcher, normalizeWeappTailwindcssGeneratorOptions, resolveTailwindSourceFromPatcher, resolveTailwindV3Source, resolveTailwindV3SourceFromPatcher, resolveTailwindV3SourceOptionsFromPatcher, resolveTailwindV4Source, resolveTailwindV4SourceFromPatchOptions, resolveTailwindV4SourceFromPatcher, resolveTailwindV4SourceOptionsFromPatcher, transformTailwindV3CssByTarget, transformTailwindV3CssToWeapp, transformTailwindV4CssByTarget, transformTailwindV4CssToWeapp };

package/dist/gulp.d.ts

@@ -1,24 +1,4 @@
-import { ITemplateHandlerOptions, CreateJsHandlerOptions } from './types.js';
-import stream from 'node:stream';
-import { e as UserDefinedOptions } from './index-BXrmQelt.js';
-import { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
-import '@babel/parser';
-import 'magic-string';
-import 'postcss';
-import 'tailwindcss-patch';
-import 'node:buffer';
-import 'webpack';
-import 'lru-cache';
-
-/**
- * @name weapp-tw-gulp
- * @description gulp版本weapp-tw插件
- * @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
- */
-declare function createPlugins(options?: UserDefinedOptions): {
-    transformWxss: (options?: Partial<IStyleHandlerOptions>) => stream.Transform;
-    transformWxml: (options?: Partial<ITemplateHandlerOptions>) => stream.Transform;
-    transformJs: (options?: Partial<CreateJsHandlerOptions>) => stream.Transform;
-};
-
-export { UserDefinedOptions, createPlugins, createPlugins as weappTailwindcss };
+export * from './bundlers/gulp/index';
+export { createPlugins as WeappTailwindcss } from './bundlers/gulp/index';
+export { createPlugins as weappTailwindcss } from './bundlers/gulp/index';
+export type { UserDefinedOptions } from './types';

package/dist/gulp.js

@@ -1,13 +1,370 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkDUHYLR2Rjs = require('./chunk-DUHYLR2R.js');
-require('./chunk-OF6MFURR.js');
-require('./chunk-HVNGIKLS.js');
-require('./chunk-ZAA5ZG3D.js');
-require('./chunk-A5PB4KZT.js');
-require('./chunk-DYLQ6UOI.js');
-require('./chunk-RKISS72P.js');
-
-
-
-exports.createPlugins = _chunkDUHYLR2Rjs.createPlugins; exports.weappTailwindcss = _chunkDUHYLR2Rjs.createPlugins;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_cache = require("./cache-BVAiJV3J.js");
+const require_runtime_patch = require("./runtime-patch-D6mBo_KB.js");
+const require_incremental_runtime_class_set = require("./incremental-runtime-class-set-BYmzQ-_f.js");
+const require_precheck = require("./precheck-B32p-gLI.js");
+const require_tailwindcss = require("./tailwindcss-Bu-RWIHx.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_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_buffer = require("node:buffer");
+let node_stream = require("node:stream");
+node_stream = require_chunk.__toESM(node_stream);
+//#region src/bundlers/gulp/index.ts
+const debug = require_runtime_patch.createDebug();
+const Transform = node_stream.default.Transform;
+/**
+* @name weapp-tw-gulp
+* @description gulp版本weapp-tw插件
+* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+*/
+function createPlugins(options = {}) {
+	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,
+		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();
+	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 });
+	}
+	function createRuntimeSetHash(rawSource, nextRuntimeSet) {
+		return cache.computeHash([
+			rawSource,
+			require_cache.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;
+		if (!require_tailwindcss.upsertTailwindV4CssSource(opts, {
+			file: node_path.default.resolve(file.path),
+			css: rawSource
+		})) 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 (node_fs.default.statSync(candidate).isFile()) return candidate;
+			} catch {
+				continue;
+			}
+		}
+	}
+	function resolveLocalModuleCandidate(base) {
+		try {
+			const stat = node_fs.default.statSync(base);
+			if (stat.isFile()) return base;
+			if (stat.isDirectory()) {
+				const resolvedIndex = resolveWithExtensions(node_path.default.join(base, "index"));
+				if (resolvedIndex) return resolvedIndex;
+			}
+		} catch {}
+		if (!node_path.default.extname(base)) return resolveWithExtensions(base);
+	}
+	function createModuleGraphOptionsFor() {
+		return {
+			resolve(specifier, importer) {
+				if (!specifier) return;
+				if (!specifier.startsWith(".") && !node_path.default.isAbsolute(specifier)) return;
+				return resolveLocalModuleCandidate(node_path.default.resolve(node_path.default.dirname(importer), specifier));
+			},
+			load(id) {
+				try {
+					return node_fs.default.readFileSync(id, "utf8");
+				} catch {
+					return;
+				}
+			},
+			filter(id) {
+				const relative = node_path.default.relative(node_process.default.cwd(), id);
+				return opts.jsMatcher(relative) || opts.wxsMatcher(relative);
+			}
+		};
+	}
+	function resolveModuleGraphOptions(moduleGraph) {
+		if (moduleGraph) return moduleGraph;
+		if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createModuleGraphOptionsFor();
+		return cachedDefaultModuleGraphOptions;
+	}
+	function createVinylTransform(handler) {
+		return new Transform({
+			objectMode: true,
+			async transform(file, _encoding, callback) {
+				try {
+					await handler(file);
+					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 || node_path.default.basename(file.path)).replaceAll(node_path.default.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(async (file) => {
+		if (!file.contents) return;
+		const rawSource = file.contents.toString();
+		const cssSourceChanged = await registerAutoCssSource(file, rawSource);
+		const nextRuntimeSet = await refreshRuntimeSet({
+			forceRefresh: cssSourceChanged,
+			forceCollect: cssSourceChanged || opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType),
+			clearCache: cssSourceChanged
+		});
+		await require_incremental_runtime_class_set.processCachedTask({
+			cache,
+			cacheKey: file.path,
+			hash: createRuntimeSetHash(rawSource, nextRuntimeSet),
+			applyResult(source) {
+				file.contents = node_buffer.Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("css cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const cssHandlerOptions = resolveWxssFileHandlerOptions(file, options);
+				const css = (await require_incremental_runtime_class_set.generateCssByGenerator({
+					opts,
+					runtimeState,
+					runtime: nextRuntimeSet,
+					rawSource,
+					file: file.path,
+					cssHandlerOptions,
+					cssUserHandlerOptions: resolveWxssUserHandlerOptions(options),
+					styleHandler,
+					debug
+				}))?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
+				debug("css handle: %s", file.path);
+				return { result: css };
+			}
+		});
+	});
+	const transformJs = (options = {}) => createVinylTransform(async (file) => {
+		if (!file.contents) return;
+		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,
+			babelParserOptions: {
+				...options?.babelParserOptions ?? {},
+				sourceFilename: filename
+			}
+		};
+		if (runtimeState.twPatcher.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.twPatcher.majorVersion;
+		await require_incremental_runtime_class_set.processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = node_buffer.Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("js cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const currentSource = file.contents?.toString() ?? rawSource;
+				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) => {
+		if (!file.contents) return;
+		const rawSource = file.contents.toString();
+		await refreshRuntimeSetForSource(file, rawSource, "html");
+		await runtimeState.readyPromise;
+		await require_incremental_runtime_class_set.processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = node_buffer.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
+exports.WeappTailwindcss = createPlugins;
+exports.createPlugins = createPlugins;
+exports.weappTailwindcss = createPlugins;