@vizejs/vite-plugin 0.0.1-alpha.8 → 0.0.1-alpha.81

package/dist/index.js

@@ -1,141 +1,537 @@
-import path from 'node:path';
-import { glob } from 'tinyglobby';
-import { compileFile } from './compiler.js';
-import { createFilter, generateOutput } from './utils.js';
-const VIRTUAL_PREFIX = '\0vize:';
-export function vize(options = {}) {
-    const filter = createFilter(options.include, options.exclude);
-    const cache = new Map();
-    // Map from virtual ID to real file path
-    const virtualToReal = new Map();
-    let isProduction;
-    let root;
-    let server = null;
-    const scanPatterns = options.scanPatterns ?? ['**/*.vue'];
-    const ignorePatterns = options.ignorePatterns ?? [
-        'node_modules/**',
-        'dist/**',
-        '.git/**',
-    ];
-    async function compileAll() {
-        const startTime = performance.now();
-        const files = await glob(scanPatterns, {
-            cwd: root,
-            ignore: ignorePatterns,
-            absolute: true,
-        });
-        console.log(`[vize] Pre-compiling ${files.length} Vue files...`);
-        let successCount = 0;
-        let errorCount = 0;
-        for (const file of files) {
-            try {
-                compileFile(file, cache, {
-                    sourceMap: options.sourceMap ?? !isProduction,
-                    ssr: options.ssr ?? false,
-                });
-                successCount++;
-            }
-            catch (e) {
-                errorCount++;
-                console.error(`[vize] Failed to compile ${file}:`, e);
-            }
-        }
-        const elapsed = (performance.now() - startTime).toFixed(2);
-        console.log(`[vize] Pre-compilation complete: ${successCount} succeeded, ${errorCount} failed (${elapsed}ms)`);
+import { transformWithOxc } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+import { glob } from "tinyglobby";
+import * as native from "@vizejs/native";
+import { createHash } from "node:crypto";
+
+//#region src/hmr.ts
+/**
+* Detect the type of HMR update needed based on content hash changes.
+*
+* @param prev - Previously compiled module (undefined if first compile)
+* @param next - Newly compiled module
+* @returns The type of HMR update needed
+*/
+function detectHmrUpdateType(prev, next) {
+	if (!prev) return "full-reload";
+	const scriptChanged = prev.scriptHash !== next.scriptHash;
+	if (scriptChanged) return "full-reload";
+	const templateChanged = prev.templateHash !== next.templateHash;
+	const styleChanged = prev.styleHash !== next.styleHash;
+	if (styleChanged && !templateChanged) return "style-only";
+	if (templateChanged) return "template-only";
+	return "full-reload";
+}
+/**
+* Generate HMR-aware code output based on update type.
+*/
+function generateHmrCode(scopeId, updateType) {
+	return `
+if (import.meta.hot) {
+  _sfc_main.__hmrId = ${JSON.stringify(scopeId)};
+  _sfc_main.__hmrUpdateType = ${JSON.stringify(updateType)};
+
+  import.meta.hot.accept((mod) => {
+    if (!mod) return;
+    const { default: updated } = mod;
+    if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+      const updateType = updated.__hmrUpdateType || 'full-reload';
+      if (updateType === 'template-only') {
+        __VUE_HMR_RUNTIME__.rerender(updated.__hmrId, updated.render);
+      } else {
+        __VUE_HMR_RUNTIME__.reload(updated.__hmrId, updated);
+      }
     }
-    function resolveVuePath(id, importer) {
-        let resolved;
-        if (path.isAbsolute(id)) {
-            resolved = id;
-        }
-        else if (importer) {
-            // Remove virtual prefix from importer if present
-            const realImporter = importer.startsWith(VIRTUAL_PREFIX)
-                ? virtualToReal.get(importer) ?? importer.slice(VIRTUAL_PREFIX.length)
-                : importer;
-            resolved = path.resolve(path.dirname(realImporter), id);
-        }
-        else {
-            resolved = path.resolve(root, id);
-        }
-        return path.normalize(resolved);
+  });
+
+  import.meta.hot.on('vize:update', (data) => {
+    if (data.id !== _sfc_main.__hmrId) return;
+
+    if (data.type === 'style-only') {
+      // Update styles without remounting component
+      const styleId = 'vize-style-' + _sfc_main.__hmrId;
+      const styleEl = document.getElementById(styleId);
+      if (styleEl && data.css) {
+        styleEl.textContent = data.css;
+      }
     }
-    return {
-        name: 'vite-plugin-vize',
-        enforce: 'pre',
-        configResolved(resolvedConfig) {
-            isProduction = options.isProduction ?? resolvedConfig.isProduction;
-            root = options.root ?? resolvedConfig.root;
-        },
-        configureServer(devServer) {
-            server = devServer;
-        },
-        async buildStart() {
-            await compileAll();
-        },
-        resolveId(id, importer) {
-            if (id.includes('?vue&type=style')) {
-                return id;
-            }
-            if (id.endsWith('.vue')) {
-                const resolved = resolveVuePath(id, importer);
-                // Return virtual module ID if cached
-                if (cache.has(resolved)) {
-                    const virtualId = VIRTUAL_PREFIX + resolved;
-                    virtualToReal.set(virtualId, resolved);
-                    return virtualId;
-                }
-            }
-            return null;
-        },
-        load(id) {
-            if (id.includes('?vue&type=style')) {
-                const [filename] = id.split('?');
-                const realPath = filename.startsWith(VIRTUAL_PREFIX)
-                    ? virtualToReal.get(filename) ?? filename.slice(VIRTUAL_PREFIX.length)
-                    : filename;
-                const compiled = cache.get(realPath);
-                if (compiled?.css) {
-                    return compiled.css;
-                }
-                return '';
-            }
-            // Handle virtual module
-            if (id.startsWith(VIRTUAL_PREFIX)) {
-                const realPath = virtualToReal.get(id) ?? id.slice(VIRTUAL_PREFIX.length);
-                const compiled = cache.get(realPath);
-                if (compiled) {
-                    return {
-                        code: generateOutput(compiled, isProduction, server !== null),
-                        map: null,
-                    };
-                }
-            }
-            return null;
-        },
-        async handleHotUpdate(ctx) {
-            const { file, server, read } = ctx;
-            if (file.endsWith('.vue') && filter(file)) {
-                try {
-                    const source = await read();
-                    compileFile(file, cache, {
-                        sourceMap: options.sourceMap ?? !isProduction,
-                        ssr: options.ssr ?? false,
-                    }, source);
-                    console.log(`[vize] Re-compiled: ${path.relative(root, file)}`);
-                }
-                catch (e) {
-                    console.error(`[vize] Re-compilation failed for ${file}:`, e);
-                }
-                // Find the virtual module for this file
-                const virtualId = VIRTUAL_PREFIX + file;
-                const modules = server.moduleGraph.getModulesByFile(virtualId)
-                    ?? server.moduleGraph.getModulesByFile(file);
-                if (modules) {
-                    return [...modules];
-                }
-            }
-        },
-    };
+  });
+
+  if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+    __VUE_HMR_RUNTIME__.createRecord(_sfc_main.__hmrId, _sfc_main);
+  }
+}`;
+}
+
+//#endregion
+//#region src/utils.ts
+function generateScopeId(filename) {
+	const hash = createHash("sha256").update(filename).digest("hex");
+	return hash.slice(0, 8);
+}
+function createFilter(include, exclude) {
+	const includePatterns = include ? Array.isArray(include) ? include : [include] : [/\.vue$/];
+	const excludePatterns = exclude ? Array.isArray(exclude) ? exclude : [exclude] : [/node_modules/];
+	return (id) => {
+		const matchInclude = includePatterns.some((pattern) => typeof pattern === "string" ? id.includes(pattern) : pattern.test(id));
+		const matchExclude = excludePatterns.some((pattern) => typeof pattern === "string" ? id.includes(pattern) : pattern.test(id));
+		return matchInclude && !matchExclude;
+	};
+}
+function generateOutput(compiled, options) {
+	const { isProduction, isDev, hmrUpdateType, extractCss } = options;
+	let output = compiled.code;
+	const exportDefaultRegex = /^export default /m;
+	const hasExportDefault = exportDefaultRegex.test(output);
+	const hasSfcMainDefined = /\bconst\s+_sfc_main\s*=/.test(output);
+	if (hasExportDefault && !hasSfcMainDefined) {
+		output = output.replace(exportDefaultRegex, "const _sfc_main = ");
+		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
+		output += "\nexport default _sfc_main;";
+	} else if (hasExportDefault && hasSfcMainDefined) {
+		if (compiled.hasScoped && compiled.scopeId) output = output.replace(/^export default _sfc_main/m, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";\nexport default _sfc_main`);
+	}
+	if (compiled.css && !(isProduction && extractCss)) {
+		const cssCode = JSON.stringify(compiled.css);
+		const cssId = JSON.stringify(`vize-style-${compiled.scopeId}`);
+		output = `
+const __vize_css__ = ${cssCode};
+const __vize_css_id__ = ${cssId};
+(function() {
+  if (typeof document !== 'undefined') {
+    let style = document.getElementById(__vize_css_id__);
+    if (!style) {
+      style = document.createElement('style');
+      style.id = __vize_css_id__;
+      style.textContent = __vize_css__;
+      document.head.appendChild(style);
+    } else {
+      style.textContent = __vize_css__;
+    }
+  }
+})();
+${output}`;
+	}
+	if (!isProduction && isDev && hasExportDefault) output += generateHmrCode(compiled.scopeId, hmrUpdateType ?? "full-reload");
+	return output;
+}
+
+//#endregion
+//#region src/compiler.ts
+const { compileSfc, compileSfcBatchWithResults } = native;
+function compileFile(filePath, cache, options, source) {
+	const content = source ?? fs.readFileSync(filePath, "utf-8");
+	const scopeId = generateScopeId(filePath);
+	const hasScoped = /<style[^>]*\bscoped\b/.test(content);
+	const result = compileSfc(content, {
+		filename: filePath,
+		sourceMap: options.sourceMap,
+		ssr: options.ssr,
+		scopeId: hasScoped ? `data-v-${scopeId}` : void 0
+	});
+	if (result.errors.length > 0) {
+		const errorMsg = result.errors.join("\n");
+		console.error(`[vize] Compilation error in ${filePath}:\n${errorMsg}`);
+	}
+	if (result.warnings.length > 0) result.warnings.forEach((warning) => {
+		console.warn(`[vize] Warning in ${filePath}: ${warning}`);
+	});
+	const compiled = {
+		code: result.code,
+		css: result.css,
+		scopeId,
+		hasScoped
+	};
+	cache.set(filePath, compiled);
+	return compiled;
+}
+/**
+* Batch compile multiple files in parallel using native Rust multithreading.
+* Returns per-file results with content hashes for HMR.
+*/
+function compileBatch(files, cache, options) {
+	const inputs = files.map((f) => ({
+		path: f.path,
+		source: f.source
+	}));
+	const result = compileSfcBatchWithResults(inputs, { ssr: options.ssr });
+	for (const fileResult of result.results) {
+		if (fileResult.errors.length === 0) cache.set(fileResult.path, {
+			code: fileResult.code,
+			css: fileResult.css,
+			scopeId: fileResult.scopeId,
+			hasScoped: fileResult.hasScoped,
+			templateHash: fileResult.templateHash,
+			styleHash: fileResult.styleHash,
+			scriptHash: fileResult.scriptHash
+		});
+		if (fileResult.errors.length > 0) console.error(`[vize] Compilation error in ${fileResult.path}:\n${fileResult.errors.join("\n")}`);
+		if (fileResult.warnings.length > 0) fileResult.warnings.forEach((warning) => {
+			console.warn(`[vize] Warning in ${fileResult.path}: ${warning}`);
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region src/index.ts
+const CONFIG_FILES = [
+	"vize.config.ts",
+	"vize.config.js",
+	"vize.config.mjs",
+	"vize.config.json"
+];
+const DEFAULT_CONFIG_ENV = {
+	mode: "development",
+	command: "serve"
+};
+/**
+* Define a Vize configuration with type checking.
+* Accepts a plain object or a function that receives ConfigEnv.
+*/
+function defineConfig(config) {
+	return config;
+}
+/**
+* Load Vize configuration from file
+*/
+async function loadConfig(root, options = {}) {
+	const { mode = "root", configFile, env } = options;
+	if (mode === "none") return null;
+	if (configFile) {
+		const configPath = path.isAbsolute(configFile) ? configFile : path.resolve(root, configFile);
+		return loadConfigFile(configPath, env);
+	}
+	if (mode === "auto") {
+		let searchDir = root;
+		while (true) {
+			const found$1 = findConfigInDir(searchDir);
+			if (found$1) return loadConfigFile(found$1, env);
+			const parentDir = path.dirname(searchDir);
+			if (parentDir === searchDir) break;
+			searchDir = parentDir;
+		}
+		return null;
+	}
+	const found = findConfigInDir(root);
+	return found ? loadConfigFile(found, env) : null;
+}
+function findConfigInDir(dir) {
+	for (const filename of CONFIG_FILES) {
+		const configPath = path.join(dir, filename);
+		if (fs.existsSync(configPath)) return configPath;
+	}
+	return null;
+}
+async function resolveConfigExport(exported, env) {
+	if (typeof exported === "function") return exported(env ?? DEFAULT_CONFIG_ENV);
+	return exported;
+}
+async function loadConfigFile(configPath, env) {
+	if (!fs.existsSync(configPath)) return null;
+	const ext = path.extname(configPath);
+	if (ext === ".json") {
+		const content = fs.readFileSync(configPath, "utf-8");
+		return JSON.parse(content);
+	}
+	try {
+		const module = await import(configPath);
+		const exported = module.default ?? module;
+		return resolveConfigExport(exported, env);
+	} catch (e) {
+		console.warn(`[vize] Failed to load config from ${configPath}:`, e);
+		return null;
+	}
+}
+/**
+* Shared config store for inter-plugin communication.
+* Key = project root, Value = resolved VizeConfig.
+* Used by musea() and other plugins to access the unified config.
+*/
+const vizeConfigStore = new Map();
+const VIRTUAL_PREFIX = "\0vize:";
+const VIRTUAL_CSS_MODULE = "virtual:vize-styles";
+const RESOLVED_CSS_MODULE = "\0vize:all-styles.css";
+function createLogger(debug) {
+	return {
+		log: (...args) => debug && console.log("[vize]", ...args),
+		info: (...args) => console.log("[vize]", ...args),
+		warn: (...args) => console.warn("[vize]", ...args),
+		error: (...args) => console.error("[vize]", ...args)
+	};
+}
+function vize(options = {}) {
+	const cache = new Map();
+	const virtualToReal = new Map();
+	const collectedCss = new Map();
+	let isProduction;
+	let root;
+	let server = null;
+	let filter;
+	let scanPatterns;
+	let ignorePatterns;
+	let mergedOptions;
+	let extractCss = false;
+	const logger = createLogger(options.debug ?? false);
+	async function compileAll() {
+		const startTime = performance.now();
+		const files = await glob(scanPatterns, {
+			cwd: root,
+			ignore: ignorePatterns,
+			absolute: true
+		});
+		logger.info(`Pre-compiling ${files.length} Vue files...`);
+		const fileContents = [];
+		for (const file of files) try {
+			const source = fs.readFileSync(file, "utf-8");
+			fileContents.push({
+				path: file,
+				source
+			});
+		} catch (e) {
+			logger.error(`Failed to read ${file}:`, e);
+		}
+		const result = compileBatch(fileContents, cache, { ssr: mergedOptions.ssr ?? false });
+		if (isProduction) {
+			for (const fileResult of result.results) if (fileResult.css) collectedCss.set(fileResult.path, fileResult.css);
+		}
+		const elapsed = (performance.now() - startTime).toFixed(2);
+		logger.info(`Pre-compilation complete: ${result.successCount} succeeded, ${result.failedCount} failed (${elapsed}ms, native batch: ${result.timeMs.toFixed(2)}ms)`);
+	}
+	function resolveVuePath(id, importer) {
+		let resolved;
+		if (id.startsWith("/@fs/")) resolved = id.slice(4);
+		else if (id.startsWith("/") && !fs.existsSync(id)) resolved = path.resolve(root, id.slice(1));
+		else if (path.isAbsolute(id)) resolved = id;
+		else if (importer) {
+			let realImporter = importer.startsWith(VIRTUAL_PREFIX) ? virtualToReal.get(importer) ?? importer.slice(VIRTUAL_PREFIX.length) : importer;
+			if (realImporter.endsWith(".vue.ts")) realImporter = realImporter.slice(0, -3);
+			resolved = path.resolve(path.dirname(realImporter), id);
+		} else resolved = path.resolve(root, id);
+		if (!path.isAbsolute(resolved)) resolved = path.resolve(root, resolved);
+		return path.normalize(resolved);
+	}
+	return {
+		name: "vite-plugin-vize",
+		enforce: "pre",
+		config() {
+			return { optimizeDeps: {
+				include: ["vue"],
+				exclude: ["virtual:vize-styles"],
+				esbuildOptions: { plugins: [{
+					name: "vize-externalize-vue",
+					setup(build) {
+						build.onResolve({ filter: /\.vue$/ }, (args) => ({
+							path: args.path,
+							external: true
+						}));
+					}
+				}] },
+				rolldownOptions: { external: [/\.vue$/] }
+			} };
+		},
+		async configResolved(resolvedConfig) {
+			root = options.root ?? resolvedConfig.root;
+			isProduction = options.isProduction ?? resolvedConfig.isProduction;
+			extractCss = isProduction;
+			const configEnv = {
+				mode: resolvedConfig.mode,
+				command: resolvedConfig.command === "build" ? "build" : "serve",
+				isSsrBuild: !!resolvedConfig.build?.ssr
+			};
+			let fileConfig = null;
+			if (options.configMode !== false) {
+				fileConfig = await loadConfig(root, {
+					mode: options.configMode ?? "root",
+					configFile: options.configFile,
+					env: configEnv
+				});
+				if (fileConfig) {
+					logger.log("Loaded config from vize.config file");
+					vizeConfigStore.set(root, fileConfig);
+				}
+			}
+			const viteConfig = fileConfig?.vite ?? {};
+			const compilerConfig = fileConfig?.compiler ?? {};
+			mergedOptions = {
+				...options,
+				ssr: options.ssr ?? compilerConfig.ssr ?? false,
+				sourceMap: options.sourceMap ?? compilerConfig.sourceMap,
+				vapor: options.vapor ?? compilerConfig.vapor ?? false,
+				include: options.include ?? viteConfig.include,
+				exclude: options.exclude ?? viteConfig.exclude,
+				scanPatterns: options.scanPatterns ?? viteConfig.scanPatterns,
+				ignorePatterns: options.ignorePatterns ?? viteConfig.ignorePatterns
+			};
+			filter = createFilter(mergedOptions.include, mergedOptions.exclude);
+			scanPatterns = mergedOptions.scanPatterns ?? ["**/*.vue"];
+			ignorePatterns = mergedOptions.ignorePatterns ?? [
+				"node_modules/**",
+				"dist/**",
+				".git/**"
+			];
+		},
+		configureServer(devServer) {
+			server = devServer;
+		},
+		async buildStart() {
+			await compileAll();
+			logger.log("Cache keys:", [...cache.keys()].slice(0, 3));
+		},
+		async resolveId(id, importer) {
+			if (id.startsWith("\0")) return null;
+			if (id.startsWith("vize:")) {
+				let realPath = id.slice(5);
+				if (realPath.endsWith(".ts")) realPath = realPath.slice(0, -3);
+				logger.log(`resolveId: redirecting stale vize: ID to ${realPath}`);
+				if (realPath.includes("node_modules")) return realPath;
+				return this.resolve(realPath, importer, { skipSelf: true });
+			}
+			if (id === VIRTUAL_CSS_MODULE) return RESOLVED_CSS_MODULE;
+			if (id.includes("?vue&type=style")) return id;
+			if (importer?.startsWith(VIRTUAL_PREFIX)) {
+				const realImporter = virtualToReal.get(importer) ?? importer.slice(VIRTUAL_PREFIX.length);
+				const cleanImporter = realImporter.endsWith(".ts") ? realImporter.slice(0, -3) : realImporter;
+				logger.log(`resolveId from virtual: id=${id}, cleanImporter=${cleanImporter}`);
+				if (!id.endsWith(".vue")) if (id.startsWith("./") || id.startsWith("../")) {
+					const [pathPart, queryPart] = id.split("?");
+					const querySuffix = queryPart ? `?${queryPart}` : "";
+					const resolved = path.resolve(path.dirname(cleanImporter), pathPart);
+					for (const ext of [
+						"",
+						".ts",
+						".tsx",
+						".js",
+						".jsx",
+						".json"
+					]) if (fs.existsSync(resolved + ext)) {
+						const finalPath = resolved + ext + querySuffix;
+						logger.log(`resolveId: resolved relative ${id} to ${finalPath}`);
+						return finalPath;
+					}
+				} else {
+					if (id.includes("/dist/") || id.includes("/lib/") || id.includes("/es/")) {
+						logger.log(`resolveId: skipping already-resolved path ${id}`);
+						return null;
+					}
+					logger.log(`resolveId: resolving external ${id} from ${cleanImporter}`);
+					const resolved = await this.resolve(id, cleanImporter, { skipSelf: true });
+					logger.log(`resolveId: resolved external ${id} to`, resolved?.id ?? "null");
+					return resolved;
+				}
+			}
+			if (id.endsWith(".vue")) {
+				if (id.includes("node_modules")) {
+					logger.log(`resolveId: skipping node_modules import ${id}`);
+					return null;
+				}
+				const resolved = resolveVuePath(id, importer);
+				if (resolved.includes("node_modules")) {
+					logger.log(`resolveId: skipping node_modules path ${resolved}`);
+					return null;
+				}
+				if (!filter(resolved)) {
+					logger.log(`resolveId: skipping filtered path ${resolved}`);
+					return null;
+				}
+				const hasCache = cache.has(resolved);
+				const fileExists = fs.existsSync(resolved);
+				logger.log(`resolveId: id=${id}, resolved=${resolved}, hasCache=${hasCache}, fileExists=${fileExists}, importer=${importer ?? "none"}`);
+				if (hasCache || fileExists) {
+					const virtualId = VIRTUAL_PREFIX + resolved + ".ts";
+					virtualToReal.set(virtualId, resolved);
+					return virtualId;
+				}
+			}
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_CSS_MODULE) {
+				const allCss = Array.from(collectedCss.values()).join("\n\n");
+				return allCss;
+			}
+			if (id.includes("?vue&type=style")) {
+				const [filename] = id.split("?");
+				const realPath = filename.startsWith(VIRTUAL_PREFIX) ? virtualToReal.get(filename) ?? filename.slice(VIRTUAL_PREFIX.length) : filename;
+				const compiled = cache.get(realPath);
+				if (compiled?.css) return compiled.css;
+				return "";
+			}
+			if (id.startsWith(VIRTUAL_PREFIX)) {
+				const lookupId = id.endsWith(".ts") ? id.slice(0, -3) : id;
+				const realPath = virtualToReal.get(id) ?? lookupId.slice(VIRTUAL_PREFIX.length);
+				const compiled = cache.get(realPath);
+				if (compiled) {
+					const output = generateOutput(compiled, {
+						isProduction,
+						isDev: server !== null,
+						extractCss
+					});
+					return {
+						code: output,
+						map: null
+					};
+				}
+			}
+			return null;
+		},
+		async transform(code, id) {
+			if (id.startsWith(VIRTUAL_PREFIX) && id.endsWith(".ts")) {
+				const result = await transformWithOxc(code, id.slice(VIRTUAL_PREFIX.length), { lang: "ts" });
+				return {
+					code: result.code,
+					map: result.map
+				};
+			}
+			return null;
+		},
+		async handleHotUpdate(ctx) {
+			const { file, server: server$1, read } = ctx;
+			if (file.endsWith(".vue") && filter(file)) try {
+				const source = await read();
+				const prevCompiled = cache.get(file);
+				compileFile(file, cache, {
+					sourceMap: mergedOptions.sourceMap ?? !isProduction,
+					ssr: mergedOptions.ssr ?? false
+				}, source);
+				const newCompiled = cache.get(file);
+				const updateType = detectHmrUpdateType(prevCompiled, newCompiled);
+				logger.log(`Re-compiled: ${path.relative(root, file)} (${updateType})`);
+				const virtualId = VIRTUAL_PREFIX + file + ".ts";
+				const modules = server$1.moduleGraph.getModulesByFile(virtualId) ?? server$1.moduleGraph.getModulesByFile(file);
+				if (updateType === "style-only" && newCompiled.css) {
+					server$1.ws.send({
+						type: "custom",
+						event: "vize:update",
+						data: {
+							id: newCompiled.scopeId,
+							type: "style-only",
+							css: newCompiled.css
+						}
+					});
+					return [];
+				}
+				if (modules) return [...modules];
+			} catch (e) {
+				logger.error(`Re-compilation failed for ${file}:`, e);
+			}
+		},
+		generateBundle(_, _bundle) {
+			if (!extractCss || collectedCss.size === 0) return;
+			const allCss = Array.from(collectedCss.values()).join("\n\n");
+			if (allCss.trim()) {
+				this.emitFile({
+					type: "asset",
+					fileName: "assets/vize-components.css",
+					source: allCss
+				});
+				logger.log(`Extracted CSS to assets/vize-components.css (${collectedCss.size} components)`);
+			}
+		}
+	};
 }
-export default vize;
+var src_default = vize;
+
+//#endregion
+export { src_default as default, defineConfig, loadConfig, vize, vizeConfigStore };