@vizejs/vite-plugin 0.0.1-alpha.100

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 vize from '@vizejs/vite-plugin'
+
+export default defineConfig({
+  plugins: [
+    vize({
+      // options
+    })
+  ]
+})
+```
+
+### Nuxt
+
+For Nuxt 3, add the plugin to your `nuxt.config.ts`:
+
+```ts
+// nuxt.config.ts
+import vize from '@vizejs/vite-plugin'
+
+export default defineNuxtConfig({
+  vite: {
+    plugins: [
+      vize({
+        // 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: [
+      vize()
+    ]
+  }
+})
+```
+
+## 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,498 @@
+import { Plugin } from "vite";
+
+//#region ../vize/src/types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface ConfigEnv {
+  mode: string;
+  command: "serve" | "build" | "check" | "lint" | "fmt";
+  isSsrBuild?: boolean;
+}
+type UserConfigExport = VizeConfig | ((env: ConfigEnv) => MaybePromise<VizeConfig>);
+type RuleSeverity = "off" | "warn" | "error";
+type RuleCategory = "correctness" | "suspicious" | "style" | "perf" | "a11y" | "security";
+/**
+ * Vize configuration options
+ */
+interface VizeConfig {
+  /**
+   * Vue compiler options
+   */
+  compiler?: CompilerConfig;
+  /**
+   * Vite plugin options
+   */
+  vite?: VitePluginConfig;
+  /**
+   * Linter options
+   */
+  linter?: LinterConfig;
+  /**
+   * Type checker options
+   */
+  typeChecker?: TypeCheckerConfig;
+  /**
+   * Formatter options
+   */
+  formatter?: FormatterConfig;
+  /**
+   * LSP options
+   */
+  lsp?: LspConfig;
+  /**
+   * Musea component gallery options
+   */
+  musea?: MuseaConfig;
+  /**
+   * Global type declarations
+   */
+  globalTypes?: GlobalTypesConfig;
+}
+/**
+ * Compiler configuration
+ */
+interface CompilerConfig {
+  /**
+   * Compilation mode
+   * @default 'module'
+   */
+  mode?: "module" | "function";
+  /**
+   * 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;
+  /**
+   * Prefix template identifiers with _ctx
+   * @default false
+   */
+  prefixIdentifiers?: boolean;
+  /**
+   * Hoist static nodes
+   * @default true
+   */
+  hoistStatic?: boolean;
+  /**
+   * Cache v-on handlers
+   * @default true
+   */
+  cacheHandlers?: boolean;
+  /**
+   * Enable TypeScript parsing in <script> blocks
+   * @default true
+   */
+  isTs?: boolean;
+  /**
+   * Script file extension for generated output
+   * @default 'ts'
+   */
+  scriptExt?: "ts" | "js";
+  /**
+   * Module name for runtime imports
+   * @default 'vue'
+   */
+  runtimeModuleName?: string;
+  /**
+   * Global variable name for runtime (IIFE builds)
+   * @default 'Vue'
+   */
+  runtimeGlobalName?: string;
+}
+/**
+ * Vite plugin configuration
+ */
+interface VitePluginConfig {
+  /**
+   * 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 configuration
+ */
+interface LinterConfig {
+  /**
+   * Enable linting
+   */
+  enabled?: boolean;
+  /**
+   * Rules to enable/disable
+   */
+  rules?: Record<string, RuleSeverity>;
+  /**
+   * Category-level severity overrides
+   */
+  categories?: Partial<Record<RuleCategory, RuleSeverity>>;
+}
+/**
+ * Type checker configuration
+ */
+interface TypeCheckerConfig {
+  /**
+   * Enable type checking
+   * @default false
+   */
+  enabled?: boolean;
+  /**
+   * Enable strict mode
+   * @default false
+   */
+  strict?: boolean;
+  /**
+   * Check component props
+   * @default true
+   */
+  checkProps?: boolean;
+  /**
+   * Check component emits
+   * @default true
+   */
+  checkEmits?: boolean;
+  /**
+   * Check template bindings
+   * @default true
+   */
+  checkTemplateBindings?: boolean;
+  /**
+   * Path to tsconfig.json
+   * @default auto-detected
+   */
+  tsconfig?: string;
+  /**
+   * Path to tsgo binary
+   */
+  tsgoPath?: string;
+}
+/**
+ * Formatter configuration
+ */
+interface FormatterConfig {
+  /**
+   * Max line width
+   * @default 80
+   */
+  printWidth?: number;
+  /**
+   * Indentation width
+   * @default 2
+   */
+  tabWidth?: number;
+  /**
+   * Use tabs for indentation
+   * @default false
+   */
+  useTabs?: boolean;
+  /**
+   * Print semicolons
+   * @default true
+   */
+  semi?: boolean;
+  /**
+   * Use single quotes
+   * @default false
+   */
+  singleQuote?: boolean;
+  /**
+   * Trailing commas
+   * @default 'all'
+   */
+  trailingComma?: "all" | "none" | "es5";
+}
+/**
+ * LSP configuration
+ */
+interface LspConfig {
+  /**
+   * Enable LSP
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Enable diagnostics
+   * @default true
+   */
+  diagnostics?: boolean;
+  /**
+   * Enable completions
+   * @default true
+   */
+  completion?: boolean;
+  /**
+   * Enable hover information
+   * @default true
+   */
+  hover?: boolean;
+  /**
+   * Enable go-to-definition
+   * @default true
+   */
+  definition?: boolean;
+  /**
+   * Enable formatting via LSP
+   * @default true
+   */
+  formatting?: boolean;
+  /**
+   * Enable code actions
+   * @default true
+   */
+  codeActions?: boolean;
+  /**
+   * Use tsgo for type checking in LSP
+   * @default false
+   */
+  tsgo?: boolean;
+}
+/**
+ * VRT (Visual Regression Testing) configuration for Musea
+ */
+interface MuseaVrtConfig {
+  /**
+   * Threshold for pixel comparison (0-1)
+   * @default 0.1
+   */
+  threshold?: number;
+  /**
+   * Output directory for screenshots
+   * @default '__musea_snapshots__'
+   */
+  outDir?: string;
+  /**
+   * Viewport sizes
+   */
+  viewports?: Array<{
+    width: number;
+    height: number;
+    name?: string;
+  }>;
+}
+/**
+ * A11y configuration for Musea
+ */
+interface MuseaA11yConfig {
+  /**
+   * Enable a11y checking
+   * @default false
+   */
+  enabled?: boolean;
+  /**
+   * Axe-core rules to enable/disable
+   */
+  rules?: Record<string, boolean>;
+}
+/**
+ * Autogen configuration for Musea
+ */
+interface MuseaAutogenConfig {
+  /**
+   * Enable auto-generation of variants
+   * @default false
+   */
+  enabled?: boolean;
+  /**
+   * Max variants to generate per component
+   * @default 10
+   */
+  maxVariants?: number;
+}
+/**
+ * Musea component gallery configuration
+ */
+interface MuseaConfig {
+  /**
+   * Glob patterns for art files
+   * @default ['**\/*.art.vue']
+   */
+  include?: string[];
+  /**
+   * Glob patterns to exclude
+   * @default ['node_modules/**', 'dist/**']
+   */
+  exclude?: string[];
+  /**
+   * Base path for gallery
+   * @default '/__musea__'
+   */
+  basePath?: string;
+  /**
+   * Enable Storybook compatibility
+   * @default false
+   */
+  storybookCompat?: boolean;
+  /**
+   * Enable inline art detection in .vue files
+   * @default false
+   */
+  inlineArt?: boolean;
+  /**
+   * VRT configuration
+   */
+  vrt?: MuseaVrtConfig;
+  /**
+   * A11y configuration
+   */
+  a11y?: MuseaA11yConfig;
+  /**
+   * Autogen configuration
+   */
+  autogen?: MuseaAutogenConfig;
+}
+/**
+ * Global type declaration
+ */
+interface GlobalTypeDeclaration {
+  /**
+   * TypeScript type string
+   */
+  type: string;
+  /**
+   * Default value
+   */
+  defaultValue?: string;
+}
+/**
+ * Global types configuration
+ */
+type GlobalTypesConfig = Record<string, GlobalTypeDeclaration | string>;
+/**
+ * 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;
+  /**
+   * Config environment for dynamic config resolution
+   */
+  env?: ConfigEnv;
+} //#endregion
+//#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
+/**
+ * Define a Vize configuration with type checking.
+ * Accepts a plain object or a function that receives ConfigEnv.
+ */
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+/**
+ * Load Vize configuration from file
+ */
+declare function loadConfig(root: string, options?: LoadConfigOptions): Promise<VizeConfig | 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.
+ */
+declare const vizeConfigStore: Map<string, VizeConfig>;
+declare function vize(options?: VizeOptions): Plugin;
+
+//#endregion
+export { CompiledModule, LoadConfigOptions, VizeConfig, VizeOptions, vize as default, defineConfig, loadConfig, vize, vizeConfigStore };

package/dist/index.js

@@ -0,0 +1,542 @@
+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);
+      }
+    }
+  });
+
+  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 { 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 this.resolve(realPath, importer, { skipSelf: true });
+				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.startsWith("#")) try {
+					return await this.resolve(id, cleanImporter, { skipSelf: true });
+				} catch {
+					return null;
+				}
+				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)`);
+			}
+		}
+	};
+}
+var src_default = vize;
+
+//#endregion
+export { src_default as default, defineConfig, loadConfig, vize, vizeConfigStore };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@vizejs/vite-plugin",
+  "version": "0.0.1-alpha.100",
+  "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
+  "publishConfig": {
+    "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/native": "0.0.1-alpha.100"
+  },
+  "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"
+  }
+}