@vizejs/vite-plugin 0.0.1-alpha.44

package/README.md

@@ -0,0 +1,214 @@
+# @vizejs/vite-plugin
+
+High-performance native Vite plugin for Vue SFC compilation powered by [Vize](https://github.com/ubugeeei/vize).
+
+## Features
+
+- **Native Performance**: Uses Rust-based compiler via Node.js native bindings (NAPI)
+- **Pre-compilation**: All `.vue` files are compiled at server startup for instant module resolution
+- **Virtual Modules**: Compiled code is served from memory as virtual modules
+- **HMR Support**: Hot Module Replacement with automatic re-compilation on file changes
+- **Vapor Mode**: Optional support for Vue Vapor mode compilation
+
+## Installation
+
+```bash
+# npm
+npm install @vizejs/vite-plugin
+
+# pnpm
+pnpm add @vizejs/vite-plugin
+
+# yarn
+yarn add @vizejs/vite-plugin
+```
+
+## Usage
+
+### Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { vizeNative } from '@vizejs/vite-plugin'
+
+export default defineConfig({
+  plugins: [
+    vizeNative({
+      // options
+    })
+  ]
+})
+```
+
+### Nuxt
+
+For Nuxt 3, add the plugin to your `nuxt.config.ts`:
+
+```ts
+// nuxt.config.ts
+import { vizeNative } from '@vizejs/vite-plugin'
+
+export default defineNuxtConfig({
+  vite: {
+    plugins: [
+      vizeNative({
+        // Exclude Nuxt's internal .vue files if needed
+        exclude: [/node_modules/, /#/, /\.nuxt/]
+      })
+    ]
+  },
+
+  // Disable the default Vue plugin
+  vue: {
+    propsDestructure: false
+  }
+})
+```
+
+**Note**: When using with Nuxt, you may need to disable Nuxt's built-in Vue plugin to avoid conflicts:
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  hooks: {
+    'vite:extendConfig': (config) => {
+      // Remove @vitejs/plugin-vue from plugins
+      config.plugins = config.plugins?.filter(
+        (p) => p && (Array.isArray(p) ? p[0] : p).name !== 'vite:vue'
+      )
+    }
+  },
+  vite: {
+    plugins: [
+      vizeNative()
+    ]
+  }
+})
+```
+
+## Options
+
+```ts
+interface VizeNativeOptions {
+  /**
+   * Files to include in compilation
+   * @default /\.vue$/
+   */
+  include?: string | RegExp | (string | RegExp)[]
+
+  /**
+   * Files to exclude from compilation
+   * @default /node_modules/
+   */
+  exclude?: string | RegExp | (string | RegExp)[]
+
+  /**
+   * Force production mode
+   * @default auto-detected from Vite config
+   */
+  isProduction?: boolean
+
+  /**
+   * Enable SSR mode
+   * @default false
+   */
+  ssr?: boolean
+
+  /**
+   * Enable source map generation
+   * @default true in development, false in production
+   */
+  sourceMap?: boolean
+
+  /**
+   * Enable Vapor mode compilation
+   * @default false
+   */
+  vapor?: boolean
+
+  /**
+   * Root directory to scan for .vue files
+   * @default Vite's root
+   */
+  root?: string
+
+  /**
+   * Glob patterns to scan for .vue files during pre-compilation
+   * @default ['**\/*.vue']
+   */
+  scanPatterns?: string[]
+
+  /**
+   * Glob patterns to ignore during pre-compilation
+   * @default ['node_modules/**', 'dist/**', '.git/**']
+   */
+  ignorePatterns?: string[]
+}
+```
+
+## How It Works
+
+### Pre-compilation at Startup
+
+When the Vite dev server starts (or build begins), the plugin:
+
+1. Scans the project root for all `.vue` files matching the configured patterns
+2. Compiles each file using the native Vize compiler
+3. Stores the compiled JavaScript and CSS in an in-memory cache
+
+This approach leverages Vize's exceptional performance - compiling 15,000 SFC files in under 500ms with multi-threading.
+
+### Virtual Module Resolution
+
+When Vite requests a `.vue` file:
+
+1. The plugin intercepts the module resolution
+2. Returns the pre-compiled code from cache (or compiles on-demand if not cached)
+3. CSS is injected inline with deduplication support
+
+### HMR (Hot Module Replacement)
+
+When a `.vue` file changes:
+
+1. The plugin detects the change via `handleHotUpdate`
+2. Re-compiles only the changed file
+3. Updates the cache
+4. Vite handles the rest of the HMR flow
+
+## Performance
+
+Vize's native compiler is significantly faster than the official Vue compiler:
+
+| Benchmark (15,000 SFCs) | @vue/compiler-sfc | Vize | Speedup |
+|-------------------------|-------------------|------|---------|
+| Single-threaded | 16.21s | 6.65s | **2.4x** |
+| Multi-threaded | 4.13s | 498ms | **8.3x** |
+
+## Comparison with vite-plugin-vize
+
+| Feature | vite-plugin-vize | vite-plugin-vize |
+|---------|------------------|-------------------------|
+| Compiler | WASM | Native (NAPI) |
+| Pre-compilation | No | Yes |
+| Module Loading | Transform | Virtual Module (Load) |
+| Performance | Fast | Fastest |
+| Platform | Any | Node.js only |
+
+Use `vite-plugin-vize` (WASM-based) when you need:
+- Browser compatibility (e.g., StackBlitz, WebContainers)
+- Platform-independent deployment
+
+Use `vite-plugin-vize` when you need:
+- Maximum performance
+- Server-side only (standard Node.js environment)
+
+## Requirements
+
+- Node.js 18+
+- Vite 5.0+ / 6.0+ / 7.0+
+- Vue 3.x
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { LoadConfigOptions, VizeConfig, defineConfig, loadConfig } from "vizejs";
+import { Plugin } from "vite";
+
+//#region src/types.d.ts
+
+interface VizeOptions {
+  /**
+   * Files to include in compilation
+   * @default /\.vue$/
+   */
+  include?: string | RegExp | (string | RegExp)[];
+  /**
+   * Files to exclude from compilation
+   * @default /node_modules/
+   */
+  exclude?: string | RegExp | (string | RegExp)[];
+  /**
+   * Force production mode
+   * @default auto-detected from Vite config
+   */
+  isProduction?: boolean;
+  /**
+   * Enable SSR mode
+   * @default false
+   */
+  ssr?: boolean;
+  /**
+   * Enable source map generation
+   * @default true in development, false in production
+   */
+  sourceMap?: boolean;
+  /**
+   * Enable Vapor mode compilation
+   * @default false
+   */
+  vapor?: boolean;
+  /**
+   * Root directory to scan for .vue files
+   * @default Vite's root
+   */
+  root?: string;
+  /**
+   * Glob patterns to scan for .vue files during pre-compilation
+   * @default ['**\/*.vue']
+   */
+  scanPatterns?: string[];
+  /**
+   * Glob patterns to ignore during pre-compilation
+   * @default ['node_modules/**', 'dist/**', '.git/**']
+   */
+  ignorePatterns?: string[];
+  /**
+   * Config file search mode
+   * - 'root': Search only in the project root directory
+   * - 'auto': Search from cwd upward until finding a config file
+   * - false: Disable config file loading
+   * @default 'root'
+   */
+  configMode?: "root" | "auto" | false;
+  /**
+   * Custom config file path (overrides automatic search)
+   */
+  configFile?: string;
+  /**
+   * Enable debug logging
+   * @default false
+   */
+  debug?: boolean;
+}
+interface CompiledModule {
+  code: string;
+  css?: string;
+  scopeId: string;
+  hasScoped: boolean;
+  templateHash?: string;
+  styleHash?: string;
+  scriptHash?: string;
+} //#endregion
+//#region src/index.d.ts
+declare function vize(options?: VizeOptions): Plugin;
+
+//#endregion
+export { CompiledModule, LoadConfigOptions, VizeConfig, VizeOptions, vize as default, defineConfig, loadConfig, vize };

package/dist/index.js

@@ -0,0 +1,447 @@
+import path from "node:path";
+import fs from "node:fs";
+import { glob } from "tinyglobby";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { defineConfig, loadConfig } from "vizejs";
+
+//#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);
+      }
+    }
+  });
+
+  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;
+      }
+    }
+  });
+
+  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 require = createRequire(import.meta.url);
+let compileSfc = null;
+let compileSfcBatchWithResults = null;
+function loadNative() {
+	if (compileSfc) return compileSfc;
+	try {
+		const native = require("@vizejs/native");
+		compileSfc = native.compileSfc;
+		return compileSfc;
+	} catch (e) {
+		throw new Error(`Failed to load @vizejs/native. Make sure it's installed and built:\n${String(e)}`);
+	}
+}
+function loadNativeBatch() {
+	if (compileSfcBatchWithResults) return compileSfcBatchWithResults;
+	try {
+		const native = require("@vizejs/native");
+		compileSfcBatchWithResults = native.compileSfcBatchWithResults;
+		return compileSfcBatchWithResults;
+	} catch (e) {
+		throw new Error(`Failed to load @vizejs/native. Make sure it's installed and built:\n${String(e)}`);
+	}
+}
+function compileFile(filePath, cache, options, source) {
+	const compile = loadNative();
+	const content = source ?? fs.readFileSync(filePath, "utf-8");
+	const scopeId = generateScopeId(filePath);
+	const hasScoped = /<style[^>]*\bscoped\b/.test(content);
+	const result = compile(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 compile = loadNativeBatch();
+	const inputs = files.map((f) => ({
+		path: f.path,
+		source: f.source
+	}));
+	const result = compile(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 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) {
+			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);
+	}
+	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;
+			let fileConfig = null;
+			if (options.configMode !== false) {
+				const { loadConfig: loadConfig$1 } = await import("vizejs");
+				fileConfig = await loadConfig$1(root, {
+					mode: options.configMode ?? "root",
+					configFile: options.configFile
+				});
+				if (fileConfig) logger.log("Loaded config from vize.config file");
+			}
+			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 === 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")) {
+				const resolved = resolveVuePath(id, importer);
+				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 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)`);
+			}
+		}
+	};
+}
+var src_default = vize;
+
+//#endregion
+export { src_default as default, defineConfig, loadConfig, vize };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@vizejs/vite-plugin",
+  "version": "0.0.1-alpha.44",
+  "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
+  "publishConfig": {
+    "provenance": true,
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "vite",
+    "vue",
+    "plugin",
+    "sfc",
+    "compiler",
+    "native",
+    "fast"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei/vize",
+    "directory": "npm/vite-plugin-vize"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.9.0",
+    "typescript": "~5.6.0",
+    "vite": "^8.0.0-beta.0"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-beta.0"
+  },
+  "dependencies": {
+    "tinyglobby": "^0.2.0",
+    "vizejs": "0.0.1-alpha.20",
+    "@vizejs/native": "0.0.1-alpha.44"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "oxlint --deny-warnings --type-aware --tsconfig tsconfig.json",
+    "lint:fix": "oxlint --type-aware --tsconfig tsconfig.json --fix",
+    "fmt": "oxfmt --write src",
+    "fmt:check": "oxfmt src"
+  }
+}