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

把 tailwindcss 原子化样式思想，带给小程序开发者们! bring tailwindcss to miniprogram developers!

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-BE34PYSC.cjs");
const require_options = require("./options-hVsoTfwL.cjs");
const require_v4_generation_core = require("./v4-generation-core-CDI6ChiH.cjs");
const require_style_options = require("./style-options-B_ppaVIg.cjs");
const require_css_imports = require("./css-imports-DfNC3e6a.cjs");
const require_pipeline_helpers = require("./pipeline-helpers-DMO0otI8.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;