@unocss/nuxt/dist/index.cjs

Nuxt module for UnoCSS

//#region rolldown:runtime
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
			key = keys[i];
			if (!__hasOwnProp.call(to, key) && key !== except) {
				__defProp(to, key, {
					get: ((k) => from[k]).bind(null, key),
					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
				});
			}
		}
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));

//#endregion
let node_path = require("node:path");
let node_process = require("node:process");
node_process = __toESM(node_process);
let node_url = require("node:url");
let _nuxt_kit = require("@nuxt/kit");
let _unocss_config = require("@unocss/config");
let _unocss_core = require("@unocss/core");
let _unocss_preset_attributify = require("@unocss/preset-attributify");
_unocss_preset_attributify = __toESM(_unocss_preset_attributify);
let _unocss_preset_icons = require("@unocss/preset-icons");
_unocss_preset_icons = __toESM(_unocss_preset_icons);
let _unocss_preset_tagify = require("@unocss/preset-tagify");
_unocss_preset_tagify = __toESM(_unocss_preset_tagify);
let _unocss_preset_typography = require("@unocss/preset-typography");
_unocss_preset_typography = __toESM(_unocss_preset_typography);
let _unocss_preset_web_fonts = require("@unocss/preset-web-fonts");
_unocss_preset_web_fonts = __toESM(_unocss_preset_web_fonts);
let _unocss_preset_wind3 = require("@unocss/preset-wind3");
_unocss_preset_wind3 = __toESM(_unocss_preset_wind3);
let _unocss_preset_wind4 = require("@unocss/preset-wind4");
_unocss_preset_wind4 = __toESM(_unocss_preset_wind4);

//#region ../../virtual-shared/integration/src/defaults.ts
const defaultPipelineExclude = [_unocss_core.cssIdRE];

//#endregion
//#region src/options.ts
function resolveOptions(options) {
	if (options.wind3 && options.wind4) {
		console.warn("[unocss/nuxt]: wind3 and wind4 presets are mutually exclusive. wind3 will be disabled in favor of wind4.");
		options.wind3 = false;
	}
	if (options.presets == null) {
		options.presets = [];
		const presetMap = {
			wind3: _unocss_preset_wind3.default,
			wind4: _unocss_preset_wind4.default,
			attributify: _unocss_preset_attributify.default,
			icons: _unocss_preset_icons.default,
			webFonts: _unocss_preset_web_fonts.default,
			typography: _unocss_preset_typography.default,
			tagify: _unocss_preset_tagify.default
		};
		for (const [key, preset] of Object.entries(presetMap)) {
			const option = options[key];
			if (option) options.presets.push(preset(typeof option === "boolean" ? {} : option));
		}
	}
	options.content ??= {};
	options.content.pipeline ??= {};
	if (options.content.pipeline !== false) {
		options.content.pipeline.exclude ??= defaultPipelineExclude;
		if (Array.isArray(options.content.pipeline.exclude)) options.content.pipeline.exclude.push(/\?macro=true/);
	}
}

//#endregion
//#region src/index.ts
const dir = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
var src_default = (0, _nuxt_kit.defineNuxtModule)({
	meta: {
		name: "unocss",
		configKey: "unocss"
	},
	defaults: {
		mode: "global",
		autoImport: true,
		preflight: false,
		components: true,
		disableNuxtInlineStyle: true,
		nuxtLayers: false,
		attributify: false,
		webFonts: false,
		icons: false,
		wind3: true,
		wind4: false
	},
	async setup(options, nuxt) {
		resolveOptions(options);
		const loadConfig = (0, _unocss_config.createRecoveryConfigLoader)();
		options.mode ??= "global";
		const InjectModes = ["global", "dist-chunk"];
		if (options.disableNuxtInlineStyle) {
			nuxt.options.features ||= {};
			nuxt.options.features.inlineStyles = false;
		}
		if (options.injectPosition != null) console.warn("[unocss/nuxt] options `injectPosition` is temporary removed due to the incompatibility with Nuxt 3.9. We are seeking for better solution. It's not effective at this moment.");
		if (options.autoImport) (0, _nuxt_kit.addPluginTemplate)({
			filename: "unocss.mjs",
			getContents: () => {
				const lines = [InjectModes.includes(options.mode) ? "import 'uno.css'" : "", "import { defineNuxtPlugin } from '#imports'; export default defineNuxtPlugin(() => {})"];
				if (options.preflight) lines.unshift("import '@unocss/reset/tailwind.css'");
				return lines.join("\n");
			}
		});
		if (options.components) (0, _nuxt_kit.addComponentsDir)({
			path: (0, node_path.resolve)(dir, "../runtime"),
			watch: false
		});
		if (options.nuxtLayers) (0, _nuxt_kit.addTemplate)({
			filename: "uno.config.mjs",
			async getContents() {
				const configPaths = (await Promise.all(nuxt.options._layers.slice(1).map((layer) => (0, _nuxt_kit.findPath)(options.configFile || ["uno.config", "unocss.config"], { cwd: layer.config.rootDir })))).filter(Boolean).reverse();
				return `import { mergeConfigs } from '@unocss/core'
${configPaths.map((path, index) => `import cfg${index} from '${path}'`.trimStart()).join("\n").trimEnd()}

export default mergeConfigs([${configPaths.map((_, index) => `cfg${index}`).join(", ")}])
`;
			},
			write: true
		});
		nuxt.hook("build:before", async () => {
			const { config: unoConfig } = await loadConfig(node_process.default.cwd(), { configFile: options.configFile }, [], options);
			if ((0, _nuxt_kit.isNuxtMajorVersion)(3, nuxt) && nuxt.options.builder === "@nuxt/vite-builder" && nuxt.options.postcss.plugins.cssnano && unoConfig.transformers?.some((t) => t.name === "@unocss/transformer-directives" && t.enforce !== "pre")) {
				const preset = nuxt.options.postcss.plugins.cssnano.preset;
				nuxt.options.postcss.plugins.cssnano = { preset: [preset?.[0] || "default", Object.assign({
					mergeRules: false,
					normalizeWhitespace: false,
					discardComments: false
				}, preset?.[1])] };
			}
			await nuxt.callHook("unocss:config", unoConfig);
			(0, _nuxt_kit.extendViteConfig)(async (config) => {
				const { default: VitePlugin } = await import("@unocss/vite");
				config.plugins = config.plugins || [];
				config.plugins.unshift(...VitePlugin({ mode: options.mode }, unoConfig));
			});
			(0, _nuxt_kit.extendWebpackConfig)(async (config) => {
				const { default: WebpackPlugin } = await import("@unocss/webpack");
				config.plugins = config.plugins || [];
				config.plugins.unshift(WebpackPlugin({}, unoConfig));
			});
		});
		if (nuxt.options.dev) nuxt.hook("devtools:customTabs", (tabs) => {
			tabs.push({
				title: "UnoCSS",
				name: "unocss",
				icon: "/__unocss/favicon.svg",
				view: {
					type: "iframe",
					src: "/__unocss/"
				}
			});
		});
	}
});

//#endregion
module.exports = src_default;