@vizejs/nuxt 0.285.0 → 0.286.0

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path, { dirname, resolve } from "node:path";
+import { parseSync } from "vite";
 import { createHash } from "node:crypto";
 //#region src/components.ts
 const COMPONENT_CALL_RE = /_?resolveComponent\s*\(\s*["'`]([^"'`]+)["'`]\s*(?:,\s*[^)]+)?\)/g;
@@ -341,62 +342,157 @@ const I18N_FN_MAP = {
 	$tm: "tm: $tm",
 	$te: "te: $te"
 };
-const I18N_FN_RE = /(?<![.\w])\$([tdn]|rt|tm|te)\s*\(/g;
-const SETUP_FN_RE = /setup\s*\(__props[\s\S]*?\)\s*\{/;
-const USE_I18N_DESTRUCTURE_RE = /const\s*\{([^}]*)\}\s*=\s*useI18n\s*\(\s*\)\s*;?/;
+const I18N_HELPER_LOCALS = new Set(Object.keys(I18N_FN_MAP));
+const DEFAULT_PARSE_ID = "vize-nuxt-i18n-bridge.tsx";
 function getLocalAlias(specifier) {
 	const colon = specifier.indexOf(":");
 	return (colon === -1 ? specifier : specifier.slice(colon + 1)).trim();
 }
-function collectUsedI18nSpecifiers(code) {
-	const used = /* @__PURE__ */ new Set();
-	let firstUseIndex = Number.POSITIVE_INFINITY;
-	for (const match of code.matchAll(I18N_FN_RE)) {
-		const specifier = I18N_FN_MAP[`$${match[1]}`];
-		if (specifier) {
-			used.add(specifier);
-			firstUseIndex = Math.min(firstUseIndex, match.index ?? firstUseIndex);
+function isNode(value) {
+	return value != null && typeof value === "object" && typeof value.type === "string";
+}
+function getNodeStart(node) {
+	return typeof node.start === "number" ? node.start : null;
+}
+function getNodeEnd(node) {
+	return typeof node.end === "number" ? node.end : null;
+}
+function getNodeName(node) {
+	return isNode(node) && typeof node.name === "string" ? node.name : null;
+}
+function getChildNodes(node) {
+	const children = [];
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) children.push(item);
+			continue;
 		}
+		if (isNode(value)) children.push(value);
 	}
-	return {
-		firstUseIndex,
-		specifiers: Array.from(used)
-	};
+	return children;
+}
+function walkNode(node, visit) {
+	visit(node);
+	for (const child of getChildNodes(node)) walkNode(child, visit);
 }
-function collectDestructuredLocalNames(destructure) {
-	const locals = /* @__PURE__ */ new Set();
-	for (const rawPart of destructure.split(",")) {
-		const part = rawPart.trim();
-		if (!part) continue;
-		const withoutDefault = (part.split("=")[0] ?? part).trim();
-		const aliasMatch = withoutDefault.match(/^(?:\.\.\.)?[^:]+:\s*(.+)$/);
-		const localName = (aliasMatch ? aliasMatch[1] : withoutDefault).trim();
-		if (localName) locals.add(localName);
+function parseProgram(code, id) {
+	try {
+		const result = parseSync(normalizeParseId(id), code);
+		if (isNode(result)) return result;
+		if (result != null && typeof result === "object") {
+			const program = result.program;
+			if (isNode(program)) return program;
+		}
+		return null;
+	} catch {
+		return null;
 	}
-	return locals;
 }
-function injectNuxtI18nHelpers(code) {
-	const setupMatch = code.match(SETUP_FN_RE);
-	if (!setupMatch || setupMatch.index === void 0) return code;
-	const setupBodyStart = setupMatch.index + setupMatch[0].length;
-	const setupBody = code.slice(setupBodyStart);
+function normalizeParseId(id) {
+	return (id.startsWith("\0") ? id.slice(1) : id).split(/[?#]/, 1)[0] || DEFAULT_PARSE_ID;
+}
+function isSetupFunction(node) {
+	if (node.type !== "Property") return false;
+	const key = isNode(node.key) ? node.key : null;
+	const value = isNode(node.value) ? node.value : null;
+	if (getNodeName(key) !== "setup" || !value) return false;
+	if (value.type !== "FunctionExpression" && value.type !== "ArrowFunctionExpression") return false;
+	return getNodeName((Array.isArray(value.params) ? value.params : [])[0]) === "__props";
+}
+function findSetupFunctionBody(program) {
+	let setupBody = null;
+	walkNode(program, (node) => {
+		if (setupBody || !isSetupFunction(node)) return;
+		const value = isNode(node.value) ? node.value : null;
+		const body = value && isNode(value.body) ? value.body : null;
+		if (body?.type === "BlockStatement") setupBody = body;
+	});
+	return setupBody;
+}
+function isUseI18nCall(node) {
+	if (!isNode(node) || node.type !== "CallExpression") return false;
+	return getNodeName(isNode(node.callee) ? node.callee : null) === "useI18n";
+}
+function collectPatternBindingNames(pattern, locals) {
+	if (pattern.type === "Identifier" && typeof pattern.name === "string") {
+		locals.add(pattern.name);
+		return;
+	}
+	if (pattern.type === "AssignmentPattern" && isNode(pattern.left)) {
+		collectPatternBindingNames(pattern.left, locals);
+		return;
+	}
+	if (pattern.type === "RestElement" && isNode(pattern.argument)) {
+		collectPatternBindingNames(pattern.argument, locals);
+		return;
+	}
+	if (pattern.type === "Property" && isNode(pattern.value)) {
+		collectPatternBindingNames(pattern.value, locals);
+		return;
+	}
+	for (const child of getChildNodes(pattern)) collectPatternBindingNames(child, locals);
+}
+function findExistingUseI18nDestructure(setupBody) {
+	const statements = Array.isArray(setupBody.body) ? setupBody.body : [];
+	for (const statement of statements) {
+		if (!isNode(statement) || statement.type !== "VariableDeclaration") continue;
+		const declarations = Array.isArray(statement.declarations) ? statement.declarations : [];
+		for (const declaration of declarations) {
+			if (!isNode(declaration) || !isNode(declaration.id) || declaration.id.type !== "ObjectPattern") continue;
+			if (!isUseI18nCall(isNode(declaration.init) ? declaration.init : null)) continue;
+			const locals = /* @__PURE__ */ new Set();
+			collectPatternBindingNames(declaration.id, locals);
+			return {
+				declaration: statement,
+				pattern: declaration.id,
+				locals
+			};
+		}
+	}
+	return null;
+}
+function collectUsedI18nSpecifiers(setupBody) {
+	const used = /* @__PURE__ */ new Map();
+	walkNode(setupBody, (node) => {
+		if (node.type !== "CallExpression") return;
+		const fnName = getNodeName(isNode(node.callee) ? node.callee : null);
+		const callStart = getNodeStart(node);
+		if (!fnName || callStart == null || !I18N_HELPER_LOCALS.has(fnName)) return;
+		if (!used.has(fnName)) used.set(fnName, callStart);
+	});
+	const helpers = Array.from(used.entries()).sort((a, b) => a[1] - b[1]);
+	return {
+		firstUseIndex: helpers[0]?.[1] ?? Number.POSITIVE_INFINITY,
+		specifiers: helpers.map(([name]) => I18N_FN_MAP[name]).filter((value) => value != null)
+	};
+}
+function injectNuxtI18nHelpers(code, id = DEFAULT_PARSE_ID) {
+	const program = parseProgram(code, id);
+	if (!program) return code;
+	const setupBody = findSetupFunctionBody(program);
+	const setupBodyStart = setupBody ? getNodeStart(setupBody) : null;
+	if (!setupBody || setupBodyStart == null) return code;
+	const insertAt = setupBodyStart + 1;
 	const { firstUseIndex, specifiers: usedSpecifiers } = collectUsedI18nSpecifiers(setupBody);
 	if (usedSpecifiers.length === 0) return code;
-	const existingMatch = setupBody.match(USE_I18N_DESTRUCTURE_RE);
-	if (existingMatch && existingMatch.index !== void 0) {
-		const existingLocals = collectDestructuredLocalNames(existingMatch[1]);
+	const existing = findExistingUseI18nDestructure(setupBody);
+	if (existing) {
 		const missingSpecifiers = usedSpecifiers.filter((specifier) => {
-			return !existingLocals.has(getLocalAlias(specifier));
+			return !existing.locals.has(getLocalAlias(specifier));
 		});
 		if (missingSpecifiers.length === 0) return code;
-		if (existingMatch.index > firstUseIndex) return code.slice(0, setupBodyStart) + `\nconst { ${missingSpecifiers.join(", ")} } = useI18n();\n` + code.slice(setupBodyStart);
-		const merged = existingMatch[1].trim();
+		const declarationStart = getNodeStart(existing.declaration);
+		const declarationEnd = getNodeEnd(existing.declaration);
+		const patternStart = getNodeStart(existing.pattern);
+		const patternEnd = getNodeEnd(existing.pattern);
+		if (declarationStart == null || declarationEnd == null || patternStart == null || patternEnd == null) return code;
+		if (declarationStart > firstUseIndex) return code.slice(0, insertAt) + `\nconst { ${missingSpecifiers.join(", ")} } = useI18n();\n` + code.slice(insertAt);
+		const merged = code.slice(patternStart + 1, patternEnd - 1).trim();
 		const nextDestructure = merged ? `${merged}, ${missingSpecifiers.join(", ")}` : missingSpecifiers.join(", ");
-		const matchStart = setupBodyStart + existingMatch.index;
-		const matchEnd = matchStart + existingMatch[0].length;
-		return code.slice(0, matchStart) + `const { ${nextDestructure} } = useI18n();` + code.slice(matchEnd);
+		return code.slice(0, declarationStart) + `const { ${nextDestructure} } = useI18n();` + code.slice(declarationEnd);
 	}
-	return code.slice(0, setupBodyStart) + `\nconst { ${usedSpecifiers.join(", ")} } = useI18n();\n` + code.slice(setupBodyStart);
+	return code.slice(0, insertAt) + `\nconst { ${usedSpecifiers.join(", ")} } = useI18n();\n` + code.slice(insertAt);
 }
 //#endregion
 //#region src/musea-components.ts
@@ -1003,7 +1099,7 @@ async function setupVizeNuxtModule(options, nuxt) {
 				}
 			}
 			if (bridgeOptions.i18n) {
-				const nextResult = injectNuxtI18nHelpers(result);
+				const nextResult = injectNuxtI18nHelpers(result, id);
 				if (nextResult !== result) {
 					result = nextResult;
 					changed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/nuxt",
-  "version": "0.285.0",
+  "version": "0.286.0",
   "description": "Nuxt module for Vize - compiler, musea gallery, linter, and type checker",
   "keywords": [
     "compiler",
@@ -42,9 +42,9 @@
   },
   "dependencies": {
     "@nuxt/kit": "3.11.2",
-    "@vizejs/vite-plugin": "0.285.0",
-    "@vizejs/vite-plugin-musea": "0.285.0",
-    "vize": "0.285.0"
+    "@vizejs/vite-plugin": "0.286.0",
+    "@vizejs/vite-plugin-musea": "0.286.0",
+    "vize": "0.286.0"
   },
   "devDependencies": {
     "typescript": "6.0.3",