@vizejs/vite-plugin 0.474.0 → 0.476.0

package/dist/{types-B3cTltTi.d.mts → types-kbMQcMYf.d.mts}

@@ -23,10 +23,6 @@ interface VizeConfig {
    * Glob patterns this config excludes
    */
   ignores?: string[];
-  /**
-   * Base config files or presets to compose
-   */
-  extends?: string | string[];
   /**
    * Vue dialect profile for standalone HTML documents; when absent the dialect is detected structurally per document
    */
@@ -178,9 +174,9 @@ interface LinterConfig {
    */
   enabled?: boolean;
   /**
-   * Built-in lint preset
+   * Built-in lint preset (happy-path is the recommended canonical name; native aliases are accepted)
    */
-  preset?: "happy-path" | "opinionated" | "essential" | "incremental" | "ecosystem" | "nuxt";
+  preset?: "general-recommended" | "general_recommended" | "generalRecommended" | "happy-path" | "happy_path" | "happy" | "default" | "recommended" | "opinionated" | "strict" | "all" | "essential" | "incremental" | "ecosystem" | "nuxt";
   /**
    * Enable native type-aware lint rules from the active lint configuration
    */
@@ -525,6 +521,10 @@ interface LanguageServerConfig {
    * Enable Vue ecosystem lint and editor helpers
    */
   ecosystem?: boolean;
+  /**
+   * Enable workspace-wide cross-file diagnostic groups (disabled by default)
+   */
+  crossFile?: boolean;
   /**
    * Enable Vue 2.7 / Nuxt 2 editor and type-checking compatibility
    */
@@ -764,10 +764,6 @@ interface VizeConfigEntry {
    * Glob patterns this entry excludes
    */
   ignores?: string[];
-  /**
-   * Base config files or presets to compose
-   */
-  extends?: string | string[];
   /**
    * Vue dialect profile for standalone HTML documents; when absent the dialect is detected structurally per document
    */
@@ -803,8 +799,8 @@ type VueConfig = {
   version?: VueVersion;
 };
 /** Native Vue settings shared by Vite, Vite+, the CLI projection and the editor. */
-type VueOptionKeys = "compiler" | "typeChecker" | "linter" | "formatter" | "languageServer" | "globalTypes" | "files" | "ignores" | "basePath" | "lib";
-/** Scoped policy currently supported by the native configuration model. */
+type VueOptionKeys = "name" | "compiler" | "experimentals" | "dialect" | "vite" | "musea" | "typeChecker" | "linter" | "formatter" | "languageServer" | "globalTypes" | "files" | "ignores" | "basePath" | "lib";
+/** Native scopes retain the same authored options inside the Vue namespace. */
 type VueOptionsEntry = Pick<VizeConfigEntry, "basePath" | "files" | "ignores" | "linter">;
 /** Section option values reuse the native types rather than a second schema. */
 type VueOptions = Pick<VizeConfig, VueOptionKeys> & {
@@ -1303,4 +1299,4 @@ interface VizeOptions extends ExperimentalPluginOptions {
   debug?: boolean;
 }
 //#endregion
-export { CompilerConfig as _, VizeInspectorLintPlanProvider as a, TypeCheckerConfig as b, VizeCompatibilityOptions as c, LoadConfigOptions as d, ResolvedVizeConfig as f, VueOptionsEntry as g, VueOptions as h, VizeVueFeatures as i, VizeVueVersion as l, UserConfigExport as m, CompiledModule as n, VizeInspectorLintPlanRequest as o, UserConfig as p, MacroArtifact as r, VizeInspectorOptions as s, VizeOptions as t, ConfigEnv as u, FormatterConfig as v, VizeConfig as x, LinterConfig as y };
+export { FormatterConfig as _, VizeInspectorLintPlanProvider as a, VizeConfig as b, VizeCompatibilityOptions as c, LoadConfigOptions as d, ResolvedVizeConfig as f, CompilerConfig as g, VueOptionsEntry as h, VizeVueFeatures as i, VizeVueVersion as l, VueOptions as m, CompiledModule as n, VizeInspectorLintPlanRequest as o, UserConfigExport as p, MacroArtifact as r, VizeInspectorOptions as s, VizeOptions as t, ConfigEnv as u, LinterConfig as v, TypeCheckerConfig as y };

package/dist/vite-plus.d.mts

@@ -1,4 +1,4 @@
-import { _ as CompilerConfig, b as TypeCheckerConfig, g as VueOptionsEntry, h as VueOptions, m as UserConfigExport, p as UserConfig$1, t as VizeOptions, v as FormatterConfig, y as LinterConfig } from "./types-B3cTltTi.mjs";
+import { _ as FormatterConfig, g as CompilerConfig, h as VueOptionsEntry, m as VueOptions, p as UserConfigExport, t as VizeOptions, v as LinterConfig, y as TypeCheckerConfig } from "./types-kbMQcMYf.mjs";
 import { ConfigEnv, UserConfig, defineConfig as defineConfig$1 } from "vite-plus";
 
 //#region src/vite-plus/types.d.ts
@@ -26,7 +26,8 @@ interface VizePackOptions {
   tsconfig?: string;
 }
 type WithPack<T> = T extends (infer Item)[] ? WithPack<Item>[] : T & {
-  vize?: VizePackOptions | false;
+  vue?: VizePackOptions | false;
+  vize?: never;
 };
 /**
  * Vite and Vite+ both accept a named plugin (including nested async options),
@@ -39,24 +40,20 @@ type CompatiblePluginOption = {
 type WithCompatiblePlugins<T> = Omit<T, "plugins"> & {
   plugins?: CompatiblePluginOption[];
 };
-type VizeSharedConfig = UserConfig$1 & {
-  /** Alias of lint.vize; lint.vize takes precedence when both are provided. */lint?: VizeLintOptions | boolean;
-};
 interface VueIntegrationConfig {
   /** Shared native Vue policy. */
   vue?: VueOptions;
-  extends?: VueConfig | VueConfig[];
   compiler?: VizeCompilerOptions | false;
   typecheck?: TypeCheckerConfig | boolean;
   lint?: UserConfig["lint"] & {
-    vize?: VizeLintOptions | boolean;
+    vue?: VizeLintOptions | boolean;
+    vize?: never;
   };
   fmt?: UserConfig["fmt"] & {
-    vize?: FormatterConfig | boolean;
+    vue?: FormatterConfig | boolean;
+    vize?: never;
   };
   pack?: WithPack<NonNullable<UserConfig["pack"]>>;
-  /** Shared native settings, including scopes, globals and editor settings. */
-  vize?: VizeSharedConfig | UserConfigExport;
 }
 type WithVize<T> = T extends ((...args: infer Args) => infer Result) ? (...args: Args) => WithVize<Result> : T extends Promise<infer Result> ? Promise<WithVize<Result>> : Omit<WithCompatiblePlugins<T>, "lint" | "fmt" | "pack"> & VueIntegrationConfig;
 type VueConfig = WithVize<VitePlusConfig>;
@@ -73,10 +70,26 @@ interface VizePlusOptions {
   /** Rename or disable generated tasks. Existing run.tasks take precedence. */
   tasks?: false | Partial<Record<VizeTask, string | false>>;
 }
-type VizePlusConfigFactory = (env: ConfigEnv) => Promise<UserConfig>;
+interface VizeTaskConfig {
+  config?: UserConfigExport;
+  options: VizePlusOptions;
+  lintTypecheck?: boolean;
+  lintLocale?: VizeLintOptions["locale"];
+  lintHelpLevel?: VizeLintOptions["helpLevel"];
+  fmtIgnorePatterns?: string[];
+}
+interface VizePlusConfigFactory {
+  (env: ConfigEnv): Promise<ConfigWithVizeTasks>;
+  /** Configure native Vue tooling without changing the existing Vite+ export. */
+  withVue(vue: VueOptions): VizePlusConfigFactory;
+}
+declare const taskConfigKey: unique symbol;
+type ConfigWithVizeTasks = UserConfig & {
+  [taskConfigKey]?: VizeTaskConfig;
+};
 //#endregion
 //#region src/vite-plus.d.ts
-/** Extend the installed Vite+ configuration with the native Vue toolchain. */
+/** Add the native Vue toolchain to an ordinary Vite+ export. */
 declare function defineConfig(config?: VueConfig, integration?: VizePlusOptions): VizePlusConfigFactory;
 /** Add Vue settings to an existing Vite+ export without another Vite+ injection. */
 declare function withVue(vue: VueOptions, vpConfig?: VitePlusConfig, integration?: VizePlusOptions): VizePlusConfigFactory;

package/dist/vite-plus.mjs

@@ -1,6 +1,5 @@
-import { i as isLegacyVueCompatibilityMode, t as mergeSharedConfig } from "./shared-config-DZHugBg2.mjs";
-import { c as projectViteConfigSource, i as resolveConfigExport, l as vueConfigOptions, r as loadConfig, s as mergeVueConfigOptions } from "./config-DNse8RdN.mjs";
-import { a as sourceConfigKey, i as resolveVitePlus, o as taskConfigKey, r as availableVueRules, t as runNative } from "./runner-Y2Iuaafy.mjs";
+import { c as projectViteConfigSource, i as resolveConfigExport, l as vueConfigOptions, s as mergeVueConfigOptions } from "./config-DE1fZbgD.mjs";
+import { a as taskConfigKey, i as sourceConfigKey, r as availableVueRules, t as runNative } from "./runner-B_lRJlux.mjs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { readFileSync } from "node:fs";
@@ -123,48 +122,25 @@ function quote(value) {
 }
 //#endregion
 //#region src/vite-plus/config.ts
-async function resolveConfig(config, env, parents = /* @__PURE__ */ new Set()) {
-	if (parents.has(config)) throw new Error("Circular extends in Vize's Vite+ config");
-	parents.add(config);
-	try {
-		if (typeof config === "function" && sourceConfigKey in config) return resolveConfig(config[sourceConfigKey], env, parents);
-		const { extends: bases, ...own } = await (typeof config === "function" ? config(env) : config);
-		if (!bases) return own;
-		let result = {};
-		const { mergeConfig } = resolveVitePlus().require("vite-plus");
-		const compose = (base, selected) => {
-			const merged = mergeConfig(base, selected);
-			const vue = mergeVueConfigOptions(base.vue, selected.vue);
-			return vue === void 0 ? merged : {
-				...merged,
-				vue
-			};
-		};
-		for (const base of Array.isArray(bases) ? bases : bases ? [bases] : []) result = compose(result, await resolveConfig(base, env, parents));
-		return compose(result, own);
-	} finally {
-		parents.delete(config);
-	}
+async function resolveConfig(config, env) {
+	if (config !== null && (typeof config === "function" || typeof config === "object") && sourceConfigKey in config) return resolveConfig(config[sourceConfigKey], env);
+	const source = await (typeof config === "function" ? config(env) : config);
+	if ("extends" in source) throw new Error("Custom config extends is no longer supported; use defineConfig(vpConfig).withVue(vueConfig)");
+	assertVueConfigSpelling(source);
+	return source;
+}
+function assertVueConfigSpelling(source) {
+	const legacy = "vize" in source ? "vize" : source.lint && "vize" in source.lint ? "lint.vize" : source.fmt && "vize" in source.fmt ? "fmt.vize" : void 0;
+	if (legacy) throw new Error(`${legacy}: configuration is no longer supported; move Vue settings to vue: in vite.config.*`);
 }
 function normalizeConfig(source, integration) {
-	const { compiler: compilerOption, typecheck, vize, lint, fmt, vue: _vue, extends: _bases, ...rest } = source;
+	assertVueConfigSpelling(source);
+	const { compiler: compilerOption, typecheck, lint, fmt, vue: _vue, ...rest } = source;
 	const vue = vueConfigOptions(source);
 	const configDirectory = process.cwd();
-	const { vize: nativeLint, ...oxlint } = lint ?? {};
-	const { vize: nativeFmt, ...oxfmt } = fmt ?? {};
-	const formatter = {
-		...oxfmt.sortImports === void 0 ? {} : { sortImports: oxfmt.sortImports },
-		...typeof nativeFmt === "object" ? nativeFmt : {}
-	};
-	const alias = vize && typeof vize === "object" && !Array.isArray(vize) ? vize.lint : void 0;
-	const lintConfig = typeof alias === "object" && typeof nativeLint === "object" ? {
-		...alias,
-		...nativeLint,
-		rules: {
-			...alias.rules,
-			...nativeLint.rules
-		}
-	} : nativeLint === void 0 ? alias : nativeLint;
+	const { vue: nativeLint, ...oxlint } = lint ?? {};
+	const { vue: nativeFmt, ...oxfmt } = fmt ?? {};
+	const lintConfig = nativeLint;
 	const compiler = vueCompiler(compilerOption ?? integration.plugin ?? {}, vue);
 	const options = {
 		...integration,
@@ -172,26 +148,9 @@ function normalizeConfig(source, integration) {
 		lint: vue?.linter?.enabled !== void 0 ? vue.linter.enabled : lintConfig === void 0 ? integration.lint : lintConfig !== false,
 		fmt: vue?.formatter !== void 0 ? true : nativeFmt === void 0 ? integration.fmt : nativeFmt !== false
 	};
-	const legacyConfig = async (env) => {
-		let base = vize;
-		if (vize && typeof vize === "object" && !Array.isArray(vize)) {
-			const { lint: _alias, ...shared } = vize;
-			base = shared;
-		}
-		const inherited = base === void 0 ? await loadConfig(process.cwd(), {
-			env,
-			viteConfig: false
-		}) : await resolveConfigExport(base, env);
-		const overrides = await resolveConfigExport({
-			...compiler === false ? {} : { compiler: nativeCompiler(compiler) },
-			...typeof typecheck === "object" ? { typeChecker: typecheck } : {},
-			...typeof lintConfig === "object" ? { linter: withoutTaskLintOptions(lintConfig) } : {},
-			...Object.keys(formatter).length ? { formatter } : {}
-		}, env);
-		return mergeSharedConfig(mergeSharedConfig(env.command === "check" && (base !== void 0 || inherited === null) ? await resolveConfigExport({ typeChecker: { jsxTypecheck: true } }, env) : null, inherited), overrides) ?? {};
-	};
+	const config = async (env) => await projectViteConfigSource(source, env, configDirectory);
 	const metadata = {
-		config: vue === void 0 ? legacyConfig : async (env) => await projectViteConfigSource(source, env, configDirectory),
+		config,
 		options,
 		lintTypecheck: typeof lintConfig === "object" && lintConfig.typecheck === true,
 		lintLocale: typeof lintConfig === "object" ? lintConfig.locale : void 0,
@@ -209,35 +168,12 @@ function normalizeConfig(source, integration) {
 		compiler
 	};
 }
-function withoutTaskLintOptions(config) {
-	const { typecheck: _typecheck, locale: _locale, helpLevel: _helpLevel, ...native } = config;
-	return native;
-}
-function nativeCompiler(options) {
-	const { compatibility, ...compiler } = options;
-	const version = options.vueVersion ?? compatibility?.vueVersion;
-	const versions = {
-		.1: "0.10",
-		.11: "0.11",
-		1: "1",
-		2: "2",
-		"2.7": "2.7",
-		3: "3",
-		legacy: "2"
-	};
-	return {
-		...compiler,
-		compatibility: {
-			...compatibility,
-			vueVersion: version === void 0 ? void 0 : versions[version]
-		}
-	};
-}
 /** Keep plugin-only fields while native canonical leaves choose their own values. */
 function vueCompiler(legacy, vue) {
 	if (vue?.compiler === void 0 && vue?.version === void 0) return legacy;
 	if (legacy === false && vue.compiler === void 0) return false;
 	const { compatibility, ...native } = vue.compiler ?? {};
+	const { vueVersion: _nativeVersion, ...nativeCompatibility } = compatibility ?? {};
 	const version = vue.version ?? compatibility?.vueVersion;
 	const versions = {
 		"0.10": .1,
@@ -253,7 +189,7 @@ function vueCompiler(legacy, vue) {
 		...native,
 		compatibility: {
 			...previous.compatibility,
-			...compatibility,
+			...nativeCompatibility,
 			...version === void 0 ? {} : { vueVersion: versions[version] }
 		},
 		...version === void 0 ? {} : { vueVersion: versions[version] }
@@ -317,7 +253,8 @@ async function emitDeclarations(options, metadata) {
 async function configurePack(input, compiler, metadata) {
 	if (input === void 0) return void 0;
 	if (Array.isArray(input)) return Promise.all(input.map(async (entry) => await configurePack(entry, compiler, metadata)));
-	const { vize: native, ...pack } = input;
+	if ("vize" in input) throw new Error("The pack.vize config option was removed. Use pack.vue instead.");
+	const { vue: native, ...pack } = input;
 	if (native === false) return pack;
 	const sourcemap = native?.sourcemap ?? pack.sourcemap;
 	const plugins = Array.isArray(pack.plugins) ? [...pack.plugins] : pack.plugins ? [pack.plugins] : [];
@@ -360,15 +297,16 @@ async function configurePack(input, compiler, metadata) {
 }
 //#endregion
 //#region src/vite-plus.ts
-/** Extend the installed Vite+ configuration with the native Vue toolchain. */
+/** Add the native Vue toolchain to an ordinary Vite+ export. */
 function defineConfig(config = {}, integration = {}) {
 	return Object.assign(async (env) => {
 		const source = await resolveConfig(config, env);
 		const { vp, metadata, compiler } = normalizeConfig(source, integration);
 		const { options } = metadata;
-		const plugins = compiler === false || isLegacyVueCompatibilityMode(compiler) ? [...vp.plugins ?? []] : await withoutVueCompiler(vp.plugins ?? []);
+		const legacy = compiler !== false && (await import("./vue-version-DGtIj1Bv.mjs")).isLegacyVueCompatibilityMode(compiler);
+		const plugins = compiler === false || legacy ? [...vp.plugins ?? []] : await withoutVueCompiler(vp.plugins ?? []);
 		if (compiler !== false) {
-			const { vize } = await import("./plugin-Cmv6xcTJ.mjs");
+			const { vize } = await import("./plugin-VGQR_WGT.mjs");
 			plugins.push(vize({
 				...compiler,
 				configMode: false,
@@ -386,9 +324,21 @@ function defineConfig(config = {}, integration = {}) {
 					...vp.run?.tasks
 				}
 			},
+			[sourceConfigKey]: source,
 			[taskConfigKey]: metadata
 		};
-	}, { [sourceConfigKey]: config });
+	}, {
+		[sourceConfigKey]: config,
+		withVue(vue) {
+			return defineConfig(async (env) => {
+				const source = await resolveConfig(config, env);
+				return {
+					...source,
+					vue: mergeVueConfigOptions(source.vue, vue)
+				};
+			}, integration);
+		}
+	});
 }
 async function withoutVueCompiler(plugins) {
 	const result = [];
@@ -401,10 +351,7 @@ async function withoutVueCompiler(plugins) {
 }
 /** Add Vue settings to an existing Vite+ export without another Vite+ injection. */
 function withVue(vue, vpConfig = {}, integration = {}) {
-	return defineConfig({
-		extends: vpConfig,
-		vue
-	}, integration);
+	return defineConfig(vpConfig, integration).withVue(vue);
 }
 //#endregion
 export { defineConfig, defineConfig as withVize, withVue };

package/dist/vue-version-BUu5UzZ5.mjs

@@ -0,0 +1,75 @@
+import { applyViteDefineReplacements, rewriteViteDynamicTemplateImports, rewriteViteImportMetaGlobBase, rewriteViteStaticAssetUrls, shouldApplyViteDefineInVirtualModule } from "@vizejs/native";
+//#region src/transform.ts
+/**
+* Code transformation utilities for Vize.
+*
+* Handles static asset URL rewriting, Vite define replacements, and
+* provides the debug logger.
+*/
+/**
+* Rewrite static asset URLs in compiled template output.
+*
+* Transforms property values like `src: "@/assets/logo.svg"` into import
+* statements hoisted to the top of the module, so Vite's module resolution
+* pipeline handles alias expansion and asset hashing in both dev and build.
+*/
+function rewriteStaticAssetUrls(code, aliasRules) {
+	if (aliasRules.length === 0 || !code.includes("src")) return code;
+	return rewriteViteStaticAssetUrls(code, aliasRules);
+}
+function rewriteDynamicTemplateImports(code, aliasRules) {
+	if (!code.includes("import(") || !code.includes("`")) return code;
+	return rewriteViteDynamicTemplateImports(code, aliasRules);
+}
+function rewriteImportMetaGlobBase(code, importer, root) {
+	if (!code.includes("import.meta.glob")) return code;
+	return rewriteViteImportMetaGlobBase(code, importer, root);
+}
+function shouldApplyDefineInVirtualModule(key) {
+	return shouldApplyViteDefineInVirtualModule(key);
+}
+/**
+* Apply Vite define replacements to code.
+* Replaces keys like `import.meta.vfFeatures.photoSection` with their values.
+* Uses word-boundary-aware matching to avoid replacing inside strings or partial matches.
+*/
+function applyDefineReplacements(code, defines) {
+	return applyViteDefineReplacements(code, Object.entries(defines).map(([key, value]) => ({
+		key,
+		value
+	})));
+}
+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)
+	};
+}
+//#endregion
+//#region src/plugin/vue-version.ts
+function isLegacyVueVersion(version) {
+	return version === "legacy" || version === .1 || version === .11 || version === 1 || version === 2 || version === "2.7";
+}
+function isLegacyVueCompatibilityMode(options) {
+	const vueVersion = options.vueVersion ?? options.compatibility?.vueVersion;
+	return (options.compatibility?.hostCompiler ?? isLegacyVueVersion(vueVersion)) && isLegacyVueVersion(vueVersion);
+}
+function hasHostVueSfcCompilerPlugin(plugins) {
+	return plugins.some((plugin) => {
+		const name = plugin.name;
+		return name === "vite:vue" || name === "vite:vue2" || name.includes("plugin-vue") || name.includes("vue2");
+	});
+}
+function createLegacyVueCompatibilityPlugin(options) {
+	return {
+		name: "vite-plugin-vize:legacy-vue-compat",
+		configResolved(resolvedConfig) {
+			if (!hasHostVueSfcCompilerPlugin(resolvedConfig.plugins)) throw new Error("vite-plugin-vize: legacy Vue host-compiler mode requires a host Vue SFC compiler plugin. Add @vitejs/plugin-vue2 (or your framework's Vue 2 Vite SFC plugin), or set compatibility.hostCompiler=false if this project can use Vize's compiler pipeline.");
+			createLogger(options.debug ?? false).log(`Legacy Vue compatibility mode is active for ${resolvedConfig.root}; Vize will not compile .vue files.`);
+		}
+	};
+}
+//#endregion
+export { applyDefineReplacements as a, rewriteImportMetaGlobBase as c, isLegacyVueVersion as i, rewriteStaticAssetUrls as l, hasHostVueSfcCompilerPlugin as n, createLogger as o, isLegacyVueCompatibilityMode as r, rewriteDynamicTemplateImports as s, createLegacyVueCompatibilityPlugin as t, shouldApplyDefineInVirtualModule as u };

package/dist/vue-version-DGtIj1Bv.mjs

@@ -0,0 +1,2 @@
+import { r as isLegacyVueCompatibilityMode } from "./vue-version-BUu5UzZ5.mjs";
+export { isLegacyVueCompatibilityMode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.474.0",
+  "version": "0.476.0",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "keywords": [
     "compiler",
@@ -51,13 +51,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@vizejs/native": "0.474.0",
-    "@vizejs/unplugin": "0.474.0",
+    "@vizejs/native": "0.476.0",
+    "@vizejs/unplugin": "0.476.0",
     "jsonc-parser": "^3.3.1",
     "oxc-parser": "0.144.0",
     "picomatch": "4.0.5",
     "tinyglobby": "0.2.17",
-    "vize": "0.474.0"
+    "vize": "0.476.0"
   },
   "devDependencies": {
     "@types/node": "25.9.2",