weapp-tailwindcss 5.1.15 → 5.2.0

package/dist/vite.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_vite = require("./vite-CBzmUTu-.cjs");
+exports.WeappTailwindcss = require_vite.WeappTailwindcss;
+exports.weappTailwindcss = require_vite.WeappTailwindcss;

package/dist/vite.d.ts

@@ -1,3 +1,3 @@
-export * from './bundlers/vite/index';
-export { WeappTailwindcss as weappTailwindcss } from './bundlers/vite/index';
-export type { UserDefinedOptions } from './types';
+export * from './bundlers/vite/index.js';
+export { WeappTailwindcss as weappTailwindcss } from './bundlers/vite/index.js';
+export type { UserDefinedOptions } from './types/index.js';

package/dist/vite.js

@@ -1,4 +1,2 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_vite = require("./vite-DUVjMduj.js");
-exports.WeappTailwindcss = require_vite.WeappTailwindcss;
-exports.weappTailwindcss = require_vite.WeappTailwindcss;
+import { t as WeappTailwindcss } from "./vite-BI1TeUPO.js";
+export { WeappTailwindcss, WeappTailwindcss as weappTailwindcss };

package/dist/watch-dependencies-BZGubvuJ.cjs

@@ -0,0 +1,40 @@
+const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+//#region src/bundlers/webpack/loaders/watch-dependencies.ts
+function normalizeWebpackWatchPath(file) {
+	return node_path.default.resolve(file);
+}
+function registerWebpackWatchFile(loaderContext, file) {
+	const resolved = normalizeWebpackWatchPath(file);
+	try {
+		if ((0, node_fs.statSync)(resolved).isDirectory()) {
+			loaderContext.addContextDependency?.(resolved);
+			return;
+		}
+		loaderContext.addDependency?.(resolved);
+	} catch {
+		if (loaderContext.addMissingDependency) {
+			loaderContext.addMissingDependency(resolved);
+			return;
+		}
+		loaderContext.addDependency?.(resolved);
+	}
+}
+function registerWebpackWatchContext(loaderContext, context) {
+	loaderContext.addContextDependency?.(normalizeWebpackWatchPath(context));
+}
+//#endregion
+Object.defineProperty(exports, "registerWebpackWatchContext", {
+	enumerable: true,
+	get: function() {
+		return registerWebpackWatchContext;
+	}
+});
+Object.defineProperty(exports, "registerWebpackWatchFile", {
+	enumerable: true,
+	get: function() {
+		return registerWebpackWatchFile;
+	}
+});

package/dist/{weapp-tw-css-generation-loader.js → weapp-tw-css-generation-loader.cjs}

@@ -1,10 +1,11 @@
-const require_weapp_tw_css_import_rewrite_loader = require("./weapp-tw-css-import-rewrite-loader-DNk0IxAt.js");
+const require_generator = require("./generator-C8D5cnbe.cjs");
+const require_weapp_tw_css_import_rewrite_loader = require("./weapp-tw-css-import-rewrite-loader.cjs");
 let node_buffer = require("node:buffer");
 //#region src/bundlers/webpack/loaders/weapp-tw-css-generation-loader.ts
 const WeappTwCssGenerationLoader = async function(source) {
 	const options = require_weapp_tw_css_import_rewrite_loader.resolveWebpackCssPipelineLoaderOptions(this.getOptions());
 	const input = node_buffer.Buffer.isBuffer(source) ? source.toString("utf-8") : source;
-	if (!(require_weapp_tw_css_import_rewrite_loader.hasTailwindRootDirectives(input, { importFallback: true }) || require_weapp_tw_css_import_rewrite_loader.hasTailwindApplyDirective(input))) return source;
+	if (!(require_generator.hasTailwindRootDirectives(input, { importFallback: true }) || require_generator.hasTailwindApplyDirective(input))) return source;
 	await require_weapp_tw_css_import_rewrite_loader.registerWebpackCssGeneratorSource(input, this.resourcePath, options);
 	return await require_weapp_tw_css_import_rewrite_loader.generateCssForWebpackPipeline(input, this, options) ?? source;
 };

package/dist/weapp-tw-css-import-rewrite-loader.cjs

@@ -0,0 +1,201 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
+const require_generator = require("./generator-C8D5cnbe.cjs");
+const require_options = require("./options-DlvhQwWB.cjs");
+const require_v4_generation_core = require("./v4-generation-core-D7MuR5ZF.cjs");
+const require_style_options = require("./style-options-CEfXwZzX.cjs");
+const require_css_imports = require("./css-imports-DfNC3e6a.cjs");
+const require_pipeline_helpers = require("./pipeline-helpers-XtUmUlci.cjs");
+const require_runtime_registry = require("./runtime-registry-Y7NrD2WH.cjs");
+const require_watch_dependencies = require("./watch-dependencies-BZGubvuJ.cjs");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_process = require("node:process");
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
+let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+let node_util = require("node:util");
+let node_buffer = require("node:buffer");
+//#region src/bundlers/webpack/loaders/weapp-tw-css-import-rewrite-loader.ts
+function resolveWebpackCssPipelineLoaderOptions(options) {
+	const runtime = require_runtime_registry.getWebpackLoaderRuntime(options?.tailwindcssImportRewriteRuntimeKey)?.cssImportRewrite;
+	return runtime ? {
+		...options,
+		tailwindcssImportRewrite: runtime
+	} : options;
+}
+function joinPosixPath(base, subpath) {
+	if (base.endsWith("/")) return `${base}${subpath}`;
+	return `${base}/${subpath}`;
+}
+function applyCssImportRewrite(source, options) {
+	const rewriteOptions = options?.tailwindcssImportRewrite;
+	const pkgDir = rewriteOptions?.pkgDir;
+	if (!pkgDir) return source;
+	return require_css_imports.rewriteTailwindcssImportsInCode(source, (0, _weapp_tailwindcss_shared.ensurePosix)(pkgDir), {
+		join: joinPosixPath,
+		appType: rewriteOptions.appType
+	}) ?? source;
+}
+function isPackageJsonImportRequest(request) {
+	return request.startsWith("#");
+}
+function normalizeCssConfigDirectives(source, resourcePath) {
+	if (!resourcePath) return source;
+	const base = node_path.default.dirname(resourcePath);
+	return source.replace(/@config\s+(["'])(.+?)\1\s*;?/g, (full, quote, request) => {
+		if (node_path.default.isAbsolute(request) || isPackageJsonImportRequest(request)) return full;
+		return `@config ${quote}${(0, _weapp_tailwindcss_shared.ensurePosix)(node_path.default.resolve(base, request))}${quote};`;
+	});
+}
+function createCssHandlerOptions(options, majorVersion, file, appType) {
+	const tailwindOptions = require_generator.resolveTailwindcssOptions(options.tailwindRuntimeOptions);
+	const cssEntries = [...options.cssEntries ?? [], ...tailwindOptions?.v4?.cssEntries ?? []].filter((entry) => typeof entry === "string" && entry.length > 0).map((entry) => node_path.default.resolve(entry));
+	const resolvedFile = node_path.default.resolve(file);
+	const matchedCssEntryIndex = cssEntries.findIndex((entry) => entry === resolvedFile);
+	return {
+		isMainChunk: matchedCssEntryIndex >= 0 ? matchedCssEntryIndex === 0 : options.mainCssChunkMatcher(file, appType),
+		postcssOptions: { options: { from: file } },
+		...require_style_options.normalizeStyleHandlerMajorVersion(majorVersion) === void 0 ? {} : { majorVersion: 4 }
+	};
+}
+async function resolveWebpackLoaderSourceCandidates(source, loaderContext, options) {
+	const compilerOptions = options?.tailwindcssImportRewrite?.compilerOptions;
+	if (!compilerOptions) return;
+	const root = compilerOptions.tailwindcssBasedir ?? node_process.default.cwd();
+	const file = loaderContext.resourcePath;
+	const resolved = await require_options.resolveTailwindV4EntriesFromCssCached(source, node_path.default.dirname(file));
+	if (!resolved) return;
+	const collector = require_v4_generation_core.createSourceCandidateStore({
+		bareArbitraryValues: compilerOptions.arbitraryValues?.bareArbitraryValues,
+		customAttributesEntities: compilerOptions.customAttributesEntities,
+		disabledDefaultTemplateHandler: compilerOptions.disabledDefaultTemplateHandler
+	});
+	collector.syncInline(resolved.inlineCandidates);
+	const outDir = loaderContext.rootContext ? node_path.default.resolve(loaderContext.rootContext, "dist") : void 0;
+	const scanFiles = await require_v4_generation_core.resolveSourceCandidateScanFiles({
+		entries: resolved.entries,
+		explicit: resolved.explicit,
+		filter: require_v4_generation_core.isSourceCandidateRequest,
+		outDir,
+		root
+	});
+	await Promise.all(scanFiles.map(async (file) => {
+		const normalizedFile = require_generator.resolveSourceScanPath(file);
+		require_watch_dependencies.registerWebpackWatchFile(loaderContext, normalizedFile);
+		await collector.syncFile(normalizedFile);
+	}));
+	const candidates = collector.valuesForEntries(resolved.entries);
+	if (candidates.size === 0) return;
+	return {
+		candidates,
+		getSourceCandidatesForEntries: collector.valuesForEntries
+	};
+}
+async function generateCssForWebpackPipeline(source, loaderContext, options) {
+	const rewriteOptions = options?.tailwindcssImportRewrite;
+	const compilerOptions = rewriteOptions?.compilerOptions;
+	const runtimeState = rewriteOptions?.runtimeState;
+	const getRuntimeSet = rewriteOptions?.getRuntimeSet;
+	if (!compilerOptions || !runtimeState || !getRuntimeSet) return;
+	await runtimeState.readyPromise;
+	const runtime = await getRuntimeSet();
+	const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(compilerOptions.generator, {
+		appType: compilerOptions.appType,
+		platform: compilerOptions.cssOptions?.platform ?? compilerOptions.platform,
+		tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+		uniAppX: compilerOptions.uniAppX
+	});
+	if (!generatorOptions.enabled) return;
+	const generatorTarget = generatorOptions.target;
+	if (generatorTarget !== "web" && generatorTarget !== "weapp") return;
+	const file = loaderContext.resourcePath;
+	const normalizedSource = normalizeCssConfigDirectives(source, file);
+	const cssHandlerOptions = createCssHandlerOptions(compilerOptions, runtimeState.tailwindRuntime.majorVersion, file, rewriteOptions.appType);
+	const sourceCandidateScan = await resolveWebpackLoaderSourceCandidates(normalizedSource, loaderContext, options);
+	const generated = await require_v4_generation_core.generateTailwindV4Css({
+		opts: compilerOptions,
+		runtimeState,
+		runtime,
+		rawSource: normalizedSource,
+		file,
+		outputFile: file,
+		getSourceCandidatesForEntries: sourceCandidateScan?.getSourceCandidatesForEntries,
+		sourceCandidates: sourceCandidateScan?.candidates,
+		cssHandlerOptions,
+		cssUserHandlerOptions: {
+			...cssHandlerOptions,
+			isMainChunk: false
+		},
+		cssStage: "raw",
+		styleHandler: compilerOptions.styleHandler,
+		debug: () => void 0,
+		deferCssAdaptation: generatorTarget !== "web"
+	});
+	if (!generated) return;
+	rewriteOptions.markGeneratedCssSource?.(file);
+	for (const dependency of generated.dependencies) require_watch_dependencies.registerWebpackWatchFile(loaderContext, dependency);
+	const generatedCss = require_generator.removeTailwindSourceDirectives(generated.css, { importFallback: true });
+	const bareUserCss = generatorTarget === "web" ? "" : require_pipeline_helpers.collectWebpackBareSelectorUserCss(normalizedSource);
+	const missingBareUserCss = bareUserCss.trim().length === 0 ? "" : (0, _weapp_tailwindcss_postcss.filterExistingCssRules)(generatedCss, bareUserCss);
+	const css = missingBareUserCss.trim().length === 0 ? generatedCss : `${generatedCss}\n${missingBareUserCss}`;
+	rewriteOptions.registerGeneratedCss?.({
+		classSet: generated.classSet,
+		css,
+		dependencies: generated.dependencies,
+		file
+	});
+	return `${require_v4_generation_core.createBundlerGeneratedCssMarker("webpack", file)}\n${css}`;
+}
+function registerWebpackCssGeneratorSource(source, resourcePath, options) {
+	const css = normalizeCssConfigDirectives(require_generator.normalizeTailwindSourceForGenerator(source, { importFallback: true }), resourcePath);
+	options?.tailwindcssImportRewrite?.registerCssSourceFile?.({
+		file: resourcePath,
+		css,
+		processed: false
+	});
+	return options?.tailwindcssImportRewrite?.registerCssSource?.({
+		file: resourcePath,
+		css
+	});
+}
+function transformCssImportRewriteSource(source, options) {
+	const input = node_buffer.Buffer.isBuffer(source) ? source.toString("utf-8") : source;
+	const rewritten = applyCssImportRewrite(input, options);
+	if (rewritten === input) return source;
+	if (node_process.default.env["WEAPP_TW_LOADER_DEBUG"]) node_process.default.stdout.write(`[weapp-tw-css-import-rewrite-loader] rewritten import ${(0, node_util.inspect)({
+		before: input.slice(0, 80),
+		after: rewritten.slice(0, 80)
+	})}\n`);
+	return rewritten;
+}
+const WeappTwCssImportRewriteLoader = function(source) {
+	if (node_process.default.env["WEAPP_TW_LOADER_DEBUG"]) node_process.default.stdout.write(`[weapp-tw-css-import-rewrite-loader] executing for ${this.resourcePath}\n`);
+	const opt = resolveWebpackCssPipelineLoaderOptions(this.getOptions());
+	const input = node_buffer.Buffer.isBuffer(source) ? source.toString("utf-8") : source;
+	const hasTailwindGeneratorSource = typeof input === "string" && (require_generator.hasTailwindRootDirectives(input, { importFallback: true }) || require_generator.hasTailwindApplyDirective(input));
+	const registerTask = hasTailwindGeneratorSource ? registerWebpackCssGeneratorSource(input, this.resourcePath, opt) : void 0;
+	const transform = () => {
+		const transformed = transformCssImportRewriteSource(source, opt);
+		if (typeof transformed === "string") return normalizeCssConfigDirectives(transformed, this.resourcePath);
+		return transformed;
+	};
+	const generate = opt?.generateCss !== false && hasTailwindGeneratorSource && opt?.tailwindcssImportRewrite?.compilerOptions && opt.tailwindcssImportRewrite.runtimeState && opt.tailwindcssImportRewrite.getRuntimeSet ? async () => {
+		return await generateCssForWebpackPipeline(input, this, opt) ?? transform();
+	} : void 0;
+	if (registerTask && typeof registerTask.then === "function") return Promise.resolve(registerTask).then(async () => {
+		if (generate) return generate();
+		return transform();
+	});
+	if (generate) return generate();
+	return transform();
+};
+//#endregion
+exports.default = WeappTwCssImportRewriteLoader;
+exports.generateCssForWebpackPipeline = generateCssForWebpackPipeline;
+exports.registerWebpackCssGeneratorSource = registerWebpackCssGeneratorSource;
+exports.resolveWebpackCssPipelineLoaderOptions = resolveWebpackCssPipelineLoaderOptions;
+exports.transformCssImportRewriteSource = transformCssImportRewriteSource;

package/dist/{weapp-tw-runtime-classset-loader.js → weapp-tw-runtime-classset-loader.cjs}

@@ -1,16 +1,14 @@
-const require_watch_dependencies = require("./watch-dependencies-bpG6kmAf.js");
-let node_buffer = require("node:buffer");
+const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
+const require_css_loader_runtime = require("./css-loader-runtime-CSv0lKqV.cjs");
+const require_runtime_registry = require("./runtime-registry-Y7NrD2WH.cjs");
+const require_watch_dependencies = require("./watch-dependencies-BZGubvuJ.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
-node_path = require_watch_dependencies.__toESM(node_path);
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_process = require("node:process");
-node_process = require_watch_dependencies.__toESM(node_process);
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
 let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
-//#region src/bundlers/webpack/shared/css-loader-runtime.ts
-function isWebpackCssLoaderRuntimeSource(source) {
-	return source.includes("___CSS_LOADER_EXPORT___") && source.includes("___CSS_LOADER_API_IMPORT___") && source.includes("module.exports = ___CSS_LOADER_EXPORT___");
-}
-//#endregion
+let node_buffer = require("node:buffer");
 //#region src/bundlers/webpack/loaders/weapp-tw-runtime-classset-loader.ts
 function isPromiseLike(value) {
 	return Boolean(value && typeof value.then === "function");
@@ -45,7 +43,7 @@ function resolveOriginalCssSource(file, source) {
 	return node_buffer.Buffer.isBuffer(source) ? source.toString("utf8") : source;
 }
 function resolveRegisteredCssSource(file, source) {
-	if (!isWebpackCssLoaderRuntimeSource(node_buffer.Buffer.isBuffer(source) ? source.toString("utf8") : source)) return resolveOriginalCssSource(file, source);
+	if (!require_css_loader_runtime.isWebpackCssLoaderRuntimeSource(node_buffer.Buffer.isBuffer(source) ? source.toString("utf8") : source)) return resolveOriginalCssSource(file, source);
 	if (isPlainCssResource(file)) try {
 		return (0, node_fs.readFileSync)(file, "utf8");
 	} catch {
@@ -65,11 +63,17 @@ function isPlainCssResource(file) {
 const WeappTwRuntimeClassSetLoader = function(source) {
 	if (node_process.default.env["WEAPP_TW_LOADER_DEBUG"]) node_process.default.stdout.write(`[weapp-tw-runtime-classset-loader] executing for ${this.resourcePath}\n`);
 	const rawOptions = this.getOptions();
-	const opt = require_watch_dependencies.getWebpackLoaderRuntime(rawOptions?.weappTailwindcssRuntimeKey)?.classSet ?? rawOptions;
-	if (this.resourcePath) opt?.registerCssSourceFile?.({
-		file: this.resourcePath,
-		css: resolveRegisteredCssSource(this.resourcePath, source)
-	});
+	const opt = require_runtime_registry.getWebpackLoaderRuntime(rawOptions?.weappTailwindcssRuntimeKey)?.classSet ?? rawOptions;
+	if (this.resourcePath) {
+		opt?.updateGeneratedCss?.({
+			file: this.resourcePath,
+			css: node_buffer.Buffer.isBuffer(source) ? source.toString("utf8") : source
+		});
+		opt?.registerCssSourceFile?.({
+			file: this.resourcePath,
+			css: resolveRegisteredCssSource(this.resourcePath, source)
+		});
+	}
 	const maybePromise = opt?.getClassSet?.();
 	const applyWatchDependencies = (dependencies) => {
 		for (const file of dependencies?.files ?? []) require_watch_dependencies.registerWebpackWatchFile(this, file);