@unocss/webpack 66.5.10-beta.1 → 66.5.11

package/dist/unplugin-DecJv6sA.cjs

@@ -0,0 +1,469 @@
+//#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_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let tinyglobby = require("tinyglobby");
+let _jridgewell_remapping = require("@jridgewell/remapping");
+_jridgewell_remapping = __toESM(_jridgewell_remapping);
+let magic_string = require("magic-string");
+magic_string = __toESM(magic_string);
+let _unocss_core = require("@unocss/core");
+let _unocss_config = require("@unocss/config");
+let unplugin_utils = require("unplugin-utils");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+let pathe = require("pathe");
+let unplugin = require("unplugin");
+let webpack_sources = require("webpack-sources");
+webpack_sources = __toESM(webpack_sources);
+
+//#region ../../virtual-shared/integration/src/constants.ts
+const INCLUDE_COMMENT = "@unocss-include";
+const IGNORE_COMMENT = "@unocss-ignore";
+const CSS_PLACEHOLDER = "@unocss-placeholder";
+const SKIP_START_COMMENT = "@unocss-skip-start";
+const SKIP_END_COMMENT = "@unocss-skip-end";
+const SKIP_COMMENT_RE = new RegExp(`(\/\/\\s*?${SKIP_START_COMMENT}\\s*?|\\/\\*\\s*?${SKIP_START_COMMENT}\\s*?\\*\\/|<!--\\s*?${SKIP_START_COMMENT}\\s*?-->)[\\s\\S]*?(\/\/\\s*?${SKIP_END_COMMENT}\\s*?|\\/\\*\\s*?${SKIP_END_COMMENT}\\s*?\\*\\/|<!--\\s*?${SKIP_END_COMMENT}\\s*?-->)`, "g");
+const VIRTUAL_ENTRY_ALIAS = [/^(?:virtual:)?uno(?::(.+))?\.css(\?.*)?$/];
+const LAYER_MARK_ALL = "__ALL__";
+
+//#endregion
+//#region ../../virtual-shared/integration/src/utils.ts
+function getPath(id) {
+	return id.replace(/\?.*$/, "");
+}
+function isCssId(id) {
+	return _unocss_core.cssIdRE.test(id);
+}
+function hash$1(str) {
+	let i;
+	let l;
+	let hval = 2166136261;
+	for (i = 0, l = str.length; i < l; i++) {
+		hval ^= str.charCodeAt(i);
+		hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
+	}
+	return `00000${(hval >>> 0).toString(36)}`.slice(-6);
+}
+function transformSkipCode(code, map, SKIP_RULES_RE, keyFlag) {
+	for (const item of Array.from(code.matchAll(SKIP_RULES_RE))) if (item != null) {
+		const matched = item[0];
+		const withHashKey = `${keyFlag}${hash$1(matched)}`;
+		map.set(withHashKey, matched);
+		code = code.replace(matched, withHashKey);
+	}
+	return code;
+}
+function restoreSkipCode(code, map) {
+	for (const [withHashKey, matched] of map.entries()) code = code.replaceAll(withHashKey, matched);
+	return code;
+}
+
+//#endregion
+//#region ../../virtual-shared/integration/src/transformers.ts
+async function applyTransformers(ctx, original, id, enforce = "default") {
+	if (original.includes(IGNORE_COMMENT)) return;
+	const transformers = (ctx.uno.config.transformers || []).filter((i) => (i.enforce || "default") === enforce);
+	if (!transformers.length) return;
+	const skipMap = /* @__PURE__ */ new Map();
+	let code = original;
+	let s = new magic_string.default(transformSkipCode(code, skipMap, SKIP_COMMENT_RE, "@unocss-skip-placeholder-"));
+	const maps = [];
+	for (const t of transformers) {
+		if (t.idFilter) {
+			if (!t.idFilter(id)) continue;
+		} else if (!ctx.filter(code, id)) continue;
+		await t.transform(s, id, ctx);
+		if (s.hasChanged()) {
+			code = restoreSkipCode(s.toString(), skipMap);
+			maps.push(s.generateMap({
+				hires: true,
+				source: id
+			}));
+			s = new magic_string.default(code);
+		}
+	}
+	if (code !== original) return {
+		code,
+		map: (0, _jridgewell_remapping.default)(maps, (_, ctx$1) => {
+			ctx$1.content = code;
+			return null;
+		})
+	};
+}
+
+//#endregion
+//#region ../../virtual-shared/integration/src/content.ts
+async function setupContentExtractor(ctx, shouldWatch = false) {
+	const { content } = await ctx.getConfig();
+	const { extract, tasks, root, filter } = ctx;
+	if (content?.inline) await Promise.all(content.inline.map(async (c, idx) => {
+		if (typeof c === "function") c = await c();
+		if (typeof c === "string") c = { code: c };
+		return extract(c.code, c.id ?? `__plain_content_${idx}__`);
+	}));
+	if (content?.filesystem) {
+		const files = await (0, tinyglobby.glob)(content.filesystem, {
+			cwd: root,
+			expandDirectories: false
+		});
+		async function extractFile(file) {
+			file = (0, node_path.isAbsolute)(file) ? file : (0, node_path.resolve)(root, file);
+			const code = await node_fs_promises.default.readFile(file, "utf-8");
+			if (!filter(code, file)) return;
+			const preTransform = await applyTransformers(ctx, code, file, "pre");
+			await applyTransformers(ctx, (await applyTransformers(ctx, preTransform?.code || code, file))?.code || preTransform?.code || code, file, "post");
+			return await extract(preTransform?.code || code, file);
+		}
+		if (shouldWatch) {
+			const { watch } = await import("chokidar");
+			watch(files, {
+				ignorePermissionErrors: true,
+				ignored: ["**/{.git,node_modules}/**"],
+				cwd: root,
+				ignoreInitial: true
+			}).on("all", (type, file) => {
+				if (type === "add" || type === "change") {
+					const absolutePath = (0, node_path.resolve)(root, file);
+					tasks.push(extractFile(absolutePath));
+				}
+			});
+		}
+		await Promise.all(files.map(extractFile));
+	}
+}
+
+//#endregion
+//#region ../../virtual-shared/integration/src/defaults.ts
+const defaultPipelineExclude = [_unocss_core.cssIdRE];
+const defaultPipelineInclude = [/\.(vue|svelte|[jt]sx|vine.ts|mdx?|astro|elm|php|phtml|marko|html)($|\?)/];
+
+//#endregion
+//#region ../../virtual-shared/integration/src/deprecation.ts
+function deprecationCheck(config) {}
+
+//#endregion
+//#region ../../virtual-shared/integration/src/context.ts
+function createContext(configOrPath, defaults = {}, extraConfigSources = [], resolveConfigResult = () => {}) {
+	let root = node_process.default.cwd();
+	let rawConfig = {};
+	let configFileList = [];
+	let uno;
+	const _uno = (0, _unocss_core.createGenerator)(rawConfig, defaults).then((r) => {
+		uno = r;
+		return r;
+	});
+	let rollupFilter = (0, unplugin_utils.createFilter)(defaultPipelineInclude, defaultPipelineExclude, { resolve: typeof configOrPath === "string" ? configOrPath : root });
+	const invalidations = [];
+	const reloadListeners = [];
+	const modules = new _unocss_core.BetterMap();
+	const tokens = /* @__PURE__ */ new Set();
+	const tasks = [];
+	const affectedModules = /* @__PURE__ */ new Set();
+	const loadConfig = (0, _unocss_config.createRecoveryConfigLoader)();
+	let ready = reloadConfig();
+	async function reloadConfig() {
+		await _uno;
+		const result = await loadConfig(root, configOrPath, extraConfigSources, defaults);
+		resolveConfigResult(result);
+		/* @__PURE__ */ deprecationCheck(result.config);
+		rawConfig = result.config;
+		configFileList = result.sources;
+		await uno.setConfig(rawConfig);
+		uno.config.envMode = "dev";
+		rollupFilter = rawConfig.content?.pipeline === false ? () => false : (0, unplugin_utils.createFilter)(rawConfig.content?.pipeline?.include || defaultPipelineInclude, rawConfig.content?.pipeline?.exclude || defaultPipelineExclude, { resolve: typeof configOrPath === "string" ? configOrPath : root });
+		tokens.clear();
+		await Promise.all(modules.map((code, id) => uno.applyExtractors(code.replace(SKIP_COMMENT_RE, ""), id, tokens)));
+		invalidate();
+		dispatchReload();
+		return result;
+	}
+	async function updateRoot(newRoot) {
+		if (newRoot !== root) {
+			root = newRoot;
+			ready = reloadConfig();
+		}
+		return await ready;
+	}
+	function invalidate() {
+		invalidations.forEach((cb) => cb());
+	}
+	function dispatchReload() {
+		reloadListeners.forEach((cb) => cb());
+	}
+	async function extract(code, id) {
+		const uno$1 = await _uno;
+		if (id) modules.set(id, code);
+		const len = tokens.size;
+		await uno$1.applyExtractors(code.replace(SKIP_COMMENT_RE, ""), id, tokens);
+		if (tokens.size > len) invalidate();
+	}
+	function filter(code, id) {
+		if (code.includes(IGNORE_COMMENT)) return false;
+		return code.includes(INCLUDE_COMMENT) || code.includes(CSS_PLACEHOLDER) || rollupFilter(id.replace(/\?v=\w+$/, ""));
+	}
+	async function getConfig() {
+		await ready;
+		return rawConfig;
+	}
+	async function flushTasks() {
+		const _tasks = [...tasks];
+		await Promise.all(_tasks);
+		if (tasks[0] === _tasks[0]) tasks.splice(0, _tasks.length);
+	}
+	/**
+	* Get regexes to match virtual module ids
+	*/
+	const vmpCache = /* @__PURE__ */ new Map();
+	async function getVMPRegexes() {
+		const prefix = (await getConfig()).virtualModulePrefix || "__uno";
+		if (vmpCache.has(prefix)) return vmpCache.get(prefix);
+		const regexes = {
+			prefix,
+			RESOLVED_ID_WITH_QUERY_RE: /* @__PURE__ */ new RegExp(`[/\\\\]${prefix}(_.*?)?\\.css(\\?.*)?$`),
+			RESOLVED_ID_RE: /* @__PURE__ */ new RegExp(`[/\\\\]${prefix}(?:_(.*?))?\.css$`)
+		};
+		vmpCache.set(prefix, regexes);
+		return regexes;
+	}
+	return {
+		get ready() {
+			return ready;
+		},
+		tokens,
+		modules,
+		affectedModules,
+		tasks,
+		flushTasks,
+		invalidate,
+		onInvalidate(fn) {
+			invalidations.push(fn);
+		},
+		filter,
+		reloadConfig,
+		onReload(fn) {
+			reloadListeners.push(fn);
+		},
+		get uno() {
+			if (!uno) throw new Error("Run `await context.ready` before accessing `context.uno`");
+			return uno;
+		},
+		extract,
+		getConfig,
+		get root() {
+			return root;
+		},
+		updateRoot,
+		getConfigFileList: () => configFileList,
+		getVMPRegexes
+	};
+}
+
+//#endregion
+//#region ../../virtual-shared/integration/src/hash.ts
+const hash = node_crypto.default.hash ?? ((algorithm, data, outputEncoding) => node_crypto.default.createHash(algorithm).update(data).digest(outputEncoding));
+function getHash(input, length = 8) {
+	return hash("sha256", input, "hex").substring(0, length);
+}
+
+//#endregion
+//#region ../../virtual-shared/integration/src/layers.ts
+async function resolveId(ctx, id, importer) {
+	const { RESOLVED_ID_WITH_QUERY_RE, prefix } = await ctx.getVMPRegexes();
+	if (id.match(RESOLVED_ID_WITH_QUERY_RE)) return id;
+	for (const alias of VIRTUAL_ENTRY_ALIAS) {
+		const match = id.match(alias);
+		if (match) {
+			let virtual = match[1] ? `${prefix}_${match[1]}.css` : `${prefix}.css`;
+			virtual += match[2] || "";
+			if (importer) virtual = (0, pathe.resolve)(importer, "..", virtual);
+			else virtual = `/${virtual}`;
+			return virtual;
+		}
+	}
+}
+async function resolveLayer(ctx, id) {
+	const { RESOLVED_ID_RE } = await ctx.getVMPRegexes();
+	const match = id.match(RESOLVED_ID_RE);
+	if (match) return match[1] || LAYER_MARK_ALL;
+}
+/**
+* 1 - layer
+* 2 - escape-view
+*                                                                   111                             222
+*/
+const LAYER_PLACEHOLDER_RE = /#--unocss--\s*\{\s*layer\s*:\s*(.+?)\s*(?:;\s*escape-view\s*:\s*(.+?)\s*)?;?\s*\}/g;
+function getLayerPlaceholder(layer) {
+	return `#--unocss--{layer:${layer};escape-view:\\"\\'\\\`\\\\}`;
+}
+function getCssEscaperForJsContent(view) {
+	if (!view) return (css) => css;
+	const prefix = {};
+	view.trim().replace(/(\\*)\\(["'`\\])/g, (_, bs, char) => {
+		prefix[char] = bs.replace(/\\\\/g, "\\");
+		return "";
+	});
+	return (css) => css.replace(/["'`\\]/g, (v) => {
+		return (prefix[v] || "") + v;
+	});
+}
+const HASH_PLACEHOLDER_RE = /#--unocss-hash--\s*\{\s*content\s*:\s*\\*"([^\\"]+)\\*";?\s*\}/g;
+function getHashPlaceholder(hash$2) {
+	return `#--unocss-hash--{content:"${hash$2}"}`;
+}
+
+//#endregion
+//#region src/unplugin.ts
+const PLUGIN_NAME = "unocss:webpack";
+const UPDATE_DEBOUNCE = 10;
+function unplugin$1(configOrPath, defaults) {
+	return (0, unplugin.createUnplugin)(() => {
+		const ctx = createContext(configOrPath, {
+			envMode: node_process.default.env.NODE_ENV === "development" ? "dev" : "build",
+			...defaults
+		});
+		const { tokens, filter, extract, onInvalidate, tasks, flushTasks } = ctx;
+		let timer;
+		onInvalidate(() => {
+			clearTimeout(timer);
+			timer = setTimeout(updateModules, UPDATE_DEBOUNCE);
+		});
+		tasks.push(setupContentExtractor(ctx, typeof configOrPath === "object" && configOrPath?.watch));
+		const entries = /* @__PURE__ */ new Set();
+		const hashes = /* @__PURE__ */ new Map();
+		const plugin = {
+			name: "unocss:webpack",
+			enforce: "pre",
+			async transform(code, id) {
+				const { RESOLVED_ID_RE } = await ctx.getVMPRegexes();
+				if (RESOLVED_ID_RE.test(id) || !filter("", id) || id.endsWith(".html")) return;
+				const result = await applyTransformers(ctx, code, id, "pre");
+				if (isCssId(id)) return result;
+				if (result == null) tasks.push(extract(code, id));
+				else tasks.push(extract(result.code, id));
+				return result;
+			},
+			async resolveId(id) {
+				const entry = await resolveId(ctx, id);
+				if (entry === id) return;
+				if (entry) {
+					let query = "";
+					const queryIndex = id.indexOf("?");
+					if (queryIndex >= 0) query = id.slice(queryIndex);
+					entries.add(entry);
+					return entry + query;
+				}
+			},
+			async load(id) {
+				const layer = await getLayer(ctx, id);
+				if (!layer) return;
+				const hash$2 = hashes.get(id);
+				return (hash$2 ? getHashPlaceholder(hash$2) : "") + getLayerPlaceholder(layer);
+			},
+			webpack(compiler) {
+				compiler.hooks.beforeCompile.tapPromise(PLUGIN_NAME, async () => {
+					await ctx.ready;
+					const nonPreTransformers = ctx.uno.config.transformers?.filter((i) => i.enforce !== "pre");
+					if (nonPreTransformers?.length) console.warn("[unocss] webpack integration only supports \"pre\" enforce transformers currently.the following transformers will be ignored\n" + nonPreTransformers.map((i) => ` - ${i.name}`).join("\n"));
+				});
+				compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+					(compilation.hooks.processAssets || compilation.hooks.optimizeAssets).tapPromise(PLUGIN_NAME, async () => {
+						await ctx.ready;
+						const files = Object.keys(compilation.assets);
+						await flushTasks();
+						const result = await ctx.uno.generate(tokens, { minify: true });
+						const resolvedLayers = (await Promise.all(Array.from(entries).map((i) => resolveLayer(ctx, i)))).filter((i) => !!i);
+						for (const file of files) {
+							if (file === "*") return;
+							let code = compilation.assets[file].source().toString();
+							let escapeCss;
+							let replaced = false;
+							code = code.replace(HASH_PLACEHOLDER_RE, "");
+							code = code.replace(LAYER_PLACEHOLDER_RE, (_, layer, escapeView) => {
+								replaced = true;
+								const css = layer.trim() === LAYER_MARK_ALL ? result.getLayers(void 0, resolvedLayers) : result.getLayer(layer) || "";
+								escapeCss = escapeCss ?? getCssEscaperForJsContent(escapeView.trim());
+								return escapeCss(css);
+							});
+							if (replaced) compilation.assets[file] = new webpack_sources.default.SourceMapSource(code, file, compilation.assets[file].map());
+						}
+					});
+				});
+			},
+			get rspack() {
+				return this.webpack;
+			}
+		};
+		let lastTokenSize = tokens.size;
+		async function updateModules() {
+			if (!plugin.__vfsModules) return;
+			await flushTasks();
+			const result = await ctx.uno.generate(tokens);
+			if (lastTokenSize === tokens.size) return;
+			lastTokenSize = tokens.size;
+			let virtualModules;
+			if (plugin.__vfsModules instanceof Map) virtualModules = Array.from(plugin.__vfsModules.keys());
+			else virtualModules = Array.from(plugin.__vfsModules);
+			const resolvedLayers = (await Promise.all(Array.from(entries).map((i) => resolveLayer(ctx, i)))).filter((i) => !!i);
+			for (const id of virtualModules) {
+				let path = decodeURIComponent(id.startsWith(plugin.__virtualModulePrefix) ? id.slice(plugin.__virtualModulePrefix.length) : id);
+				path = normalizeAbsolutePath(path);
+				const layer = await resolveLayer(ctx, path);
+				if (!layer) continue;
+				const code = layer === LAYER_MARK_ALL ? result.getLayers(void 0, resolvedLayers) : result.getLayer(layer) || "";
+				const hash$2 = getHash(code);
+				hashes.set(path, hash$2);
+				plugin.__vfs.writeModule(id, code);
+			}
+		}
+		return plugin;
+	});
+}
+async function getLayer(ctx, id) {
+	let layer = await resolveLayer(ctx, getPath(id));
+	if (!layer) {
+		const entry = await resolveId(ctx, id);
+		if (entry) layer = await resolveLayer(ctx, entry);
+	}
+	return layer;
+}
+function normalizeAbsolutePath(path) {
+	if ((0, node_path.isAbsolute)(path)) return (0, node_path.normalize)(path);
+	else return path;
+}
+
+//#endregion
+Object.defineProperty(exports, 'unplugin', {
+  enumerable: true,
+  get: function () {
+    return unplugin$1;
+  }
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unocss/webpack",
   "type": "module",
-  "version": "66.5.10-beta.1",
+  "version": "66.5.11",
   "description": "The Webpack plugin for UnoCSS",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -44,10 +44,11 @@
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.cts",
   "typesVersions": {
     "*": {
       "*": [
+        "./dist/*.d.cts",
         "./dist/*",
         "./*"
       ]
@@ -61,24 +62,23 @@
   },
   "dependencies": {
     "@jridgewell/remapping": "^2.3.5",
-    "chokidar": "^3.6.0",
+    "chokidar": "^5.0.0",
     "magic-string": "^0.30.21",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.15",
-    "unplugin": "^2.3.10",
+    "unplugin": "^2.3.11",
     "unplugin-utils": "^0.3.1",
     "webpack-sources": "^3.3.3",
-    "@unocss/config": "66.5.10-beta.1",
-    "@unocss/core": "66.5.10-beta.1"
+    "@unocss/config": "66.5.11",
+    "@unocss/core": "66.5.11"
   },
   "devDependencies": {
     "@types/webpack": "^5.28.5",
     "@types/webpack-sources": "^3.2.3",
-    "webpack": "^5.102.1"
+    "webpack": "^5.104.1"
   },
   "scripts": {
-    "build": "unbuild",
-    "stub": "unbuild --stub",
-    "test:attw": "attw --pack"
+    "build": "tsdown --config-loader unrun",
+    "dev": "tsdown --config-loader unrun --watch"
   }
 }

package/dist/index.d.ts

@@ -1,15 +0,0 @@
-import * as webpack from 'webpack';
-import { UserConfig, UserConfigDefaults } from '@unocss/core';
-
-interface WebpackPluginOptions<Theme extends object = object> extends UserConfig<Theme> {
-    /**
-     * Manually enable watch mode
-     *
-     * @default false
-     */
-    watch?: boolean;
-}
-declare function WebpackPlugin<Theme extends object>(configOrPath?: WebpackPluginOptions<Theme> | string, defaults?: UserConfigDefaults): webpack.WebpackPluginInstance;
-
-export = WebpackPlugin;
-export type { WebpackPluginOptions };

package/dist/rspack.d.ts

@@ -1,7 +0,0 @@
-import { UserConfigDefaults } from '@unocss/core';
-import { WebpackPluginOptions } from './index.js';
-import 'webpack';
-
-declare function UnoCSSRspackPlugin<Theme extends object>(configOrPath?: WebpackPluginOptions<Theme> | string, defaults?: UserConfigDefaults): RspackPluginInstance;
-
-export { UnoCSSRspackPlugin };