@vizejs/vite-plugin 0.0.1-alpha.73 → 0.0.1-alpha.9

package/README.md

@@ -30,11 +30,11 @@ yarn add @vizejs/vite-plugin
 ```ts
 // vite.config.ts
 import { defineConfig } from 'vite'
-import vize from '@vizejs/vite-plugin'
+import { vizeNative } from '@vizejs/vite-plugin'
 
 export default defineConfig({
   plugins: [
-    vize({
+    vizeNative({
       // options
     })
   ]
@@ -47,12 +47,12 @@ For Nuxt 3, add the plugin to your `nuxt.config.ts`:
 
 ```ts
 // nuxt.config.ts
-import vize from '@vizejs/vite-plugin'
+import { vizeNative } from '@vizejs/vite-plugin'
 
 export default defineNuxtConfig({
   vite: {
     plugins: [
-      vize({
+      vizeNative({
         // Exclude Nuxt's internal .vue files if needed
         exclude: [/node_modules/, /#/, /\.nuxt/]
       })
@@ -81,7 +81,7 @@ export default defineNuxtConfig({
   },
   vite: {
     plugins: [
-      vize()
+      vizeNative()
     ]
   }
 })

package/dist/compiler.d.ts

@@ -0,0 +1,6 @@
+import type { CompileSfcFn, CompiledModule } from './types.js';
+export declare function loadNative(): CompileSfcFn;
+export declare function compileFile(filePath: string, cache: Map<string, CompiledModule>, options: {
+    sourceMap: boolean;
+    ssr: boolean;
+}, source?: string): CompiledModule;

package/dist/compiler.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { generateScopeId } from './utils.js';
+const require = createRequire(import.meta.url);
+let compileSfc = null;
+export 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${e}`);
+    }
+}
+export 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}` : undefined,
+    });
+    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;
+}

package/dist/index.d.ts

@@ -1,170 +1,5 @@
-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;
-}
-/**
- * Vize configuration options
- */
-interface VizeConfig {
-  /**
-   * Vue compiler options
-   */
-  compiler?: {
-    /**
-     * Enable Vapor mode compilation
-     * @default false
-     */
-    vapor?: boolean;
-    /**
-     * Enable SSR mode
-     * @default false
-     */
-    ssr?: boolean;
-    /**
-     * Enable source map generation
-     * @default true in development, false in production
-     */
-    sourceMap?: boolean;
-  };
-  /**
-   * Vite plugin options
-   */
-  vite?: {
-    /**
-     * 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)[];
-    /**
-     * 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[];
-  };
-  /**
-   * Linter options
-   */
-  linter?: {
-    /**
-     * Enable linting
-     */
-    enabled?: boolean;
-    /**
-     * Rules to enable/disable
-     */
-    rules?: Record<string, "off" | "warn" | "error">;
-  };
-}
-/**
- * Options for loading vize.config file
- */
-interface LoadConfigOptions {
-  /**
-   * Config file search mode
-   * - 'root': Search only in the specified root directory
-   * - 'auto': Search from cwd upward until finding a config file
-   * - 'none': Don't load config file
-   * @default 'root'
-   */
-  mode?: "root" | "auto" | "none";
-  /**
-   * Custom config file path (overrides automatic search)
-   */
-  configFile?: string;
-} //#endregion
-//#region src/index.d.ts
-/**
- * Define a Vize configuration with type checking
- */
-declare function defineConfig(config: VizeConfig): VizeConfig;
-/**
- * Load Vize configuration from file
- */
-declare function loadConfig(root: string, options?: LoadConfigOptions): Promise<VizeConfig | null>;
-declare function vize(options?: VizeOptions): Plugin;
-
-//#endregion
-export { CompiledModule, LoadConfigOptions, VizeConfig, VizeOptions, vize as default, defineConfig, loadConfig, vize };
+import type { Plugin } from 'vite';
+import type { VizeOptions, CompiledModule } from './types.js';
+export type { VizeOptions, CompiledModule };
+export declare function vize(options?: VizeOptions): Plugin;
+export default vize;

package/dist/index.js

@@ -1,495 +1,141 @@
-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);
-      }
-    }
-  });
-
-  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;
-      }
+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)`);
     }
-  });
-
-  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__;
+    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);
     }
-  }
-})();
-${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.cjs",
-	"vize.config.json"
-];
-/**
-* Define a Vize configuration with type checking
-*/
-function defineConfig(config) {
-	return config;
-}
-/**
-* Load Vize configuration from file
-*/
-async function loadConfig(root, options = {}) {
-	const { mode = "root", configFile } = options;
-	if (mode === "none") return null;
-	const searchMode = mode === "auto" ? "nearest" : mode;
-	if (configFile) {
-		const configPath = path.isAbsolute(configFile) ? configFile : path.resolve(root, configFile);
-		return loadConfigFile(configPath);
-	}
-	let searchDir = root;
-	while (true) {
-		for (const filename of CONFIG_FILES) {
-			const configPath = path.join(searchDir, filename);
-			if (fs.existsSync(configPath)) return loadConfigFile(configPath);
-		}
-		if (searchMode === "root") break;
-		const parentDir = path.dirname(searchDir);
-		if (parentDir === searchDir) break;
-		searchDir = parentDir;
-	}
-	return null;
-}
-async function loadConfigFile(configPath) {
-	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);
-		return module.default ?? module;
-	} catch (e) {
-		console.warn(`[vize] Failed to load config from ${configPath}:`, e);
-		return null;
-	}
-}
-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;
-			let fileConfig = null;
-			if (options.configMode !== false) {
-				fileConfig = await loadConfig(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.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 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)`);
-			}
-		}
-	};
+    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];
+                }
+            }
+        },
+    };
 }
-var src_default = vize;
-
-//#endregion
-export { src_default as default, defineConfig, loadConfig, vize };
+export default vize;

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+export interface SfcCompileOptionsNapi {
+    filename?: string;
+    sourceMap?: boolean;
+    ssr?: boolean;
+    scopeId?: string;
+}
+export interface SfcCompileResultNapi {
+    code: string;
+    css?: string;
+    errors: string[];
+    warnings: string[];
+}
+export type CompileSfcFn = (source: string, options?: SfcCompileOptionsNapi) => SfcCompileResultNapi;
+export 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[];
+}
+export interface CompiledModule {
+    code: string;
+    css?: string;
+    scopeId: string;
+    hasScoped: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledModule } from './types.js';
+export declare function generateScopeId(filename: string): string;
+export declare function createFilter(include?: string | RegExp | (string | RegExp)[], exclude?: string | RegExp | (string | RegExp)[]): (id: string) => boolean;
+export declare function generateOutput(compiled: CompiledModule, isProduction: boolean, isDev: boolean): string;

package/dist/utils.js

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto';
+export function generateScopeId(filename) {
+    const hash = createHash('sha256').update(filename).digest('hex');
+    return hash.slice(0, 8);
+}
+export 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;
+    };
+}
+export function generateOutput(compiled, isProduction, isDev) {
+    let output = compiled.code;
+    // Rewrite "export default" to named variable for HMR
+    const hasExportDefault = output.includes('export default');
+    if (hasExportDefault) {
+        output = output.replace('export default', 'const _sfc_main =');
+        output += '\nexport default _sfc_main;';
+    }
+    // Inject CSS
+    if (compiled.css) {
+        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}`;
+    }
+    // Add HMR support in development
+    if (!isProduction && isDev && hasExportDefault) {
+        output += `
+if (import.meta.hot) {
+  _sfc_main.__hmrId = ${JSON.stringify(compiled.scopeId)};
+  import.meta.hot.accept((mod) => {
+    if (!mod) return;
+    const { default: updated } = mod;
+    if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+      __VUE_HMR_RUNTIME__.reload(_sfc_main.__hmrId, updated);
+    }
+  });
+  if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+    __VUE_HMR_RUNTIME__.createRecord(_sfc_main.__hmrId, _sfc_main);
+  }
+}`;
+    }
+    return output;
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.0.1-alpha.73",
+  "version": "0.0.1-alpha.9",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "publishConfig": {
-    "provenance": true,
+    "provenance": false,
     "access": "public"
   },
   "type": "module",
@@ -15,6 +15,10 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
   "files": [
     "dist"
   ],
@@ -27,31 +31,15 @@
     "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",
+    "@vizejs/native": "workspace:*",
+    "tinyglobby": "^0.2.0",
     "typescript": "~5.6.0",
-    "vite": "^8.0.0-beta.0"
+    "vite": "^7.3.1"
   },
   "peerDependencies": {
-    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-beta.0"
-  },
-  "dependencies": {
-    "tinyglobby": "^0.2.0",
-    "@vizejs/native": "0.0.1-alpha.73"
-  },
-  "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"
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0"
   }
-}
+}