@vizejs/nuxt 0.674.0 → 0.676.0

package/dist/index.mjs

@@ -495,6 +495,33 @@ function patchNuxtHostVuePluginForCompilerExcludes(plugin, compilerOptions) {
 	plugin[VIZE_NUXT_HOST_VUE_EXCLUDE_PATCHED] = true;
 	return true;
 }
+function isHostVueCompiler(entry) {
+	if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+	const plugin = entry;
+	return plugin.name === "vite:vue" && hasHostVueCompilerHooks(plugin);
+}
+function withoutPlugin(entry, plugin) {
+	if (entry === plugin) return [];
+	if (!Array.isArray(entry)) return entry;
+	return entry.filter((item) => item !== plugin).map((item) => withoutPlugin(item, plugin));
+}
+function holdsPlugin(entry, plugin) {
+	return entry === plugin || Array.isArray(entry) && entry.some((item) => holdsPlugin(item, plugin));
+}
+/**
+* Nuxt lists its host `vite:vue` before its own plugins, and Vize registers with
+* the modules' plugins after them. Move Vize's compile stage to the host
+* compiler's place in this config, so Nuxt's transforms keep their order around
+* the compiler. The registered plugin array, shared by every config, is left as
+* it is.
+*/
+function placeVizeCompileStage(plugins, stage) {
+	const host = plugins.findIndex(isHostVueCompiler);
+	const holder = plugins.findIndex((entry) => holdsPlugin(entry, stage));
+	if (host === -1 || holder === -1) return;
+	plugins[holder] = withoutPlugin(plugins[holder], stage);
+	plugins.splice(host, 0, stage);
+}
 function hasHostVueCompilerHooks(plugin) {
 	return hasHookHandler(plugin.resolveId) || hasHookHandler(plugin.load) || hasHookHandler(plugin.transform) || hasHookHandler(plugin.handleHotUpdate);
 }
@@ -888,6 +915,13 @@ const NUXT_VUE_TYPE_GATED_TRANSFORMS = new Set([
 	"nuxt:prehydrate-transform",
 	"nuxt:navigate-to-early-return"
 ]);
+/**
+* Nuxt transforms of the SFC text, ordered before the compiler, whose gate
+* admits only the whole file or a template block. `nuxt:components-loader-pre`
+* and `nuxt:server-only-component-transform` gate on `isVue(id)`, which a Vize
+* id passes as it is.
+*/
+const NUXT_SFC_SOURCE_TRANSFORMS = new Set(["nuxt:server-devonly:transform"]);
 /** The id Vize gives a compiled SFC module (`Foo.vue?vue&vize`). */
 const VIZE_VUE_MODULE_ID_RE = /\.vue\?vue&vize(?:-ssr)?(?:&|$)/;
 /**
@@ -901,6 +935,12 @@ function toNuxtVueTransformId(id) {
 	if (marker.test(id)) return id.replace(marker, "$1vue&type=script");
 	return `${id}${id.includes("?") ? "&" : "?"}vue&type=script`;
 }
+/** @vitejs/plugin-vue's id for a transform of the whole SFC text: the file itself. */
+function toNuxtSfcSourceTransformId(id) {
+	if (!isVizeGeneratedVueModuleId(id)) return id;
+	const queryIndex = id.indexOf("?");
+	return (queryIndex === -1 ? id : id.slice(0, queryIndex)).replace(/\.vue\.tsx?$/, ".vue");
+}
 function isFilterPatternList(value) {
 	return typeof value === "string" || value instanceof RegExp || Array.isArray(value);
 }
@@ -936,16 +976,18 @@ function admitVizeModulesInHookFilter(filter) {
 }
 /**
 * Nuxt's core transforms classify Vue submodules by their `type=` query. Vize
-* owns a single generated JavaScript module for the complete SFC, so expose it
-* as the script submodule only for those transforms and retain its canonical
-* Vite identity everywhere else.
+* owns a single module for the complete SFC, so expose it as the script
+* submodule to the transforms after the compiler and as the file itself to
+* those of the SFC text, and retain its canonical Vite identity everywhere else.
 */
 function patchNuxtVueTypeGatedTransform(plugin) {
-	if (!plugin || plugin.__vizeNuxtVueTransformPatched || !plugin.name || !NUXT_VUE_TYPE_GATED_TRANSFORMS.has(plugin.name)) return;
+	if (!plugin || plugin.__vizeNuxtVueTransformPatched || !plugin.name) return;
+	const toHostId = NUXT_VUE_TYPE_GATED_TRANSFORMS.has(plugin.name) ? toNuxtVueTransformId : NUXT_SFC_SOURCE_TRANSFORMS.has(plugin.name) ? toNuxtSfcSourceTransformId : null;
+	if (!toHostId) return;
 	if (typeof plugin.transform === "function") {
 		const original = plugin.transform;
 		plugin.transform = function(code, id, ...args) {
-			return original.call(this, code, toNuxtVueTransformId(id), ...args);
+			return original.call(this, code, toHostId(id), ...args);
 		};
 		plugin.__vizeNuxtVueTransformPatched = true;
 		return;
@@ -955,7 +997,7 @@ function patchNuxtVueTypeGatedTransform(plugin) {
 	if (transform.filter !== void 0) transform.filter = admitVizeModulesInHookFilter(transform.filter);
 	const original = transform.handler;
 	transform.handler = function(code, id, ...args) {
-		return original.call(this, code, toNuxtVueTransformId(id), ...args);
+		return original.call(this, code, toHostId(id), ...args);
 	};
 	plugin.__vizeNuxtVueTransformPatched = true;
 }
@@ -1193,17 +1235,28 @@ function mergePlainRecords(...values) {
 }
 //#endregion
 //#region src/vite-compiler.ts
-/** Keep lazy plugin loading and native-only registration outside the module entry. */
-async function setupNuxtViteCompiler(compilerOptions, host, compiler) {
+/**
+* Keep lazy plugin loading and native-only registration outside the module
+* entry. Vize's SFC compile stage takes the host compiler's place in each
+* config; this hook runs before the module's own, which drops that compiler.
+*/
+async function setupNuxtViteCompiler(compilerOptions, nuxt, compiler) {
 	const { default: vize } = await import("@vizejs/vite-plugin");
+	const host = nuxt.options;
 	const { options: explicit, defaults } = splitNuxtCompilerDefaults(compilerOptions, compiler, host.vue?.compilerOptions);
 	host.vite ||= {};
 	host.vite.plugins = host.vite.plugins || [];
-	host.vite.plugins.push(vize({
+	const plugins = vize({
 		...explicit,
 		nuxtPageMeta: true,
 		ssrModuleIdRoot: host.srcDir
-	}, defaults, "nuxt"));
+	}, defaults, "nuxt");
+	host.vite.plugins.push(plugins);
+	const stage = plugins.find((plugin) => plugin.name === "vite-plugin-vize:sfc");
+	if (!stage) return;
+	nuxt.hook("vite:configResolved", (config) => {
+		placeVizeCompileStage(config.plugins, stage);
+	});
 }
 //#endregion
 //#region src/libraries.ts
@@ -1483,7 +1536,7 @@ async function setupVizeNuxtModule(raw, nuxt) {
 	}
 	await setupLintInspector(options.lint, nuxt, compilerOptions, lintGeneration, nuxt.options.dev);
 	const usesVizeCompiler = shouldUseVizeCompiler(compilerOptions);
-	if (compilerOptions !== false && compilerOptions.compatibility?.hostCompiler !== true) await setupNuxtViteCompiler(compilerOptions, nuxt.options, options.compiler);
+	if (compilerOptions !== false && compilerOptions.compatibility?.hostCompiler !== true) await setupNuxtViteCompiler(compilerOptions, nuxt, options.compiler);
 	let isNuxtBuild = false;
 	let isViteBuild = false;
 	if (usesVizeCompiler) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/nuxt",
-  "version": "0.674.0",
+  "version": "0.676.0",
   "description": "Nuxt module for Vize - compiler, musea gallery, linter, and type checker",
   "keywords": [
     "compiler",
@@ -49,15 +49,15 @@
   },
   "dependencies": {
     "@nuxt/kit": "3.21.8",
-    "@vizejs/native": "0.674.0",
-    "@vizejs/nuxt-lint-config": "0.674.0",
-    "@vizejs/vite-plugin": "0.674.0",
-    "@vizejs/vite-plugin-musea": "0.674.0",
-    "vize": "0.674.0"
+    "@vizejs/native": "0.676.0",
+    "@vizejs/nuxt-lint-config": "0.676.0",
+    "@vizejs/vite-plugin": "0.676.0",
+    "@vizejs/vite-plugin-musea": "0.676.0",
+    "vize": "0.676.0"
   },
   "devDependencies": {
     "jiti-nuxt2": "npm:jiti@1.21.7",
-    "oxlint-plugin-vize": "0.674.0",
+    "oxlint-plugin-vize": "0.676.0",
     "typescript": "6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.3.0",
     "vite-plus": "1.3.0",