@ripast/vue 0.0.1 → 0.2.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { extractTemplateExpressions, posToLineCol, rewriteTemplateReferences } from "@ripast/core/adapter";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { extractTemplateExpressions, hyphenateVueName, isInsideAutoImportScope, posToLineCol, rewriteTemplateReferences, rgFiles, scan } from "@ripast/core/adapter";
 import { URI } from "vscode-uri";
 import process from "node:process";
 import { FileType, createLanguage, createLanguageService, createUriMap } from "@volar/language-service";
@@ -273,6 +273,346 @@ async function getDiags(vue, fileName) {
 function diagKey(d) {
 	return `${d.range.start.line}:${d.range.start.character}:${d.code ?? ""}:${d.message}`;
 }
+const MODULE_EXT_RE = /\.(?:tsx?|jsx?|mts|cts|mjs|cjs|vue)$/;
+const WIN_SEP_RE = /\\/g;
+function isGeneratedNuxtPath(cwd, filePath) {
+	const rel = relative(cwd, filePath).replace(/\\/g, "/");
+	return rel === ".nuxt" || rel.startsWith(".nuxt/");
+}
+function removeGeneratedNuxtChanges(cwd, changes) {
+	for (let i = changes.length - 1; i >= 0; i--) if (isGeneratedNuxtPath(cwd, changes[i].path)) changes.splice(i, 1);
+}
+function loadNuxtPathAliases(cwd) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [
+		join(cwd, ".nuxt/tsconfig.json"),
+		join(cwd, ".nuxt/tsconfig.app.json"),
+		join(cwd, "tsconfig.json")
+	];
+	for (const candidate of candidates) {
+		if (!existsSync(candidate)) continue;
+		for (const alias of readTsconfigPaths(candidate)) {
+			const key = `${alias.pattern}|${alias.targets.join(",")}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			out.push(alias);
+		}
+	}
+	return out;
+}
+function readTsconfigPaths(tsconfigPath) {
+	const visited = /* @__PURE__ */ new Set();
+	return collect(tsconfigPath);
+	function collect(path) {
+		if (visited.has(path) || !existsSync(path)) return [];
+		visited.add(path);
+		let json;
+		try {
+			json = JSON.parse(stripJsonComments(readFileSync(path, "utf8")));
+		} catch {
+			return [];
+		}
+		const out = [];
+		const co = json.compilerOptions ?? {};
+		const baseUrl = co.baseUrl ? resolve(dirname(path), co.baseUrl) : dirname(path);
+		const paths = co.paths ?? {};
+		for (const [pattern, raw] of Object.entries(paths)) {
+			if (!Array.isArray(raw) || !raw.length) continue;
+			const wildcard = pattern.endsWith("/*");
+			const targets = raw.map((t) => resolve(baseUrl, wildcard ? t.replace(/\/\*$/, "") : t));
+			out.push({
+				pattern,
+				targets,
+				wildcard
+			});
+		}
+		if (json.extends) {
+			const exts = Array.isArray(json.extends) ? json.extends : [json.extends];
+			for (const ext of exts) {
+				const resolved = ext.startsWith(".") ? resolve(dirname(path), ext) : ext;
+				const withExt = /\.json$/.test(resolved) ? resolved : `${resolved}.json`;
+				out.push(...collect(withExt));
+			}
+		}
+		return out;
+	}
+}
+function stripJsonComments(source) {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function resolveBestImportSpecifier(fromFile, toFile, aliases, oldSpec) {
+	const targetAlias = pickAliasFor(toFile, aliases);
+	const sourceAlias = pickAliasFor(fromFile, aliases);
+	if (!!targetAlias && (!sourceAlias || sourceAlias.matchedRoot !== targetAlias.matchedRoot) && targetAlias) return formatAliasSpecifier(targetAlias, oldSpec);
+	return formatRelativeSpecifier(fromFile, toFile, oldSpec);
+}
+function pickAliasFor(file, aliases) {
+	const normFile = file.replace(WIN_SEP_RE, "/");
+	let best = null;
+	for (const alias of aliases) for (const target of alias.targets) {
+		const normTarget = target.replace(WIN_SEP_RE, "/");
+		if (alias.wildcard) {
+			if (normFile === normTarget || normFile.startsWith(`${normTarget}/`)) {
+				const remainder = normFile === normTarget ? "" : normFile.slice(normTarget.length + 1);
+				if (!best || normTarget.length > best.matchedRoot.length) best = {
+					pattern: alias.pattern,
+					matchedRoot: normTarget,
+					remainder,
+					wildcard: true
+				};
+			}
+		} else if (normFile === normTarget || stripModuleExt(normFile) === normTarget) {
+			if (!best || normTarget.length > best.matchedRoot.length) best = {
+				pattern: alias.pattern,
+				matchedRoot: normTarget,
+				remainder: "",
+				wildcard: false
+			};
+		}
+	}
+	return best;
+}
+function formatAliasSpecifier(match, oldSpec) {
+	if (!match.wildcard) return match.pattern;
+	const base = match.pattern.replace(/\/\*$/, "");
+	const tail = oldSpec !== void 0 && MODULE_EXT_RE.test(oldSpec) ? match.remainder : match.remainder.replace(MODULE_EXT_RE, "");
+	return tail ? `${base}/${tail}` : base;
+}
+function formatRelativeSpecifier(fromFile, toFile, oldSpec) {
+	const hasExt = oldSpec !== void 0 && MODULE_EXT_RE.test(oldSpec);
+	let rel = relative(dirname(fromFile), toFile).replace(WIN_SEP_RE, "/");
+	if (!hasExt) rel = rel.replace(MODULE_EXT_RE, "");
+	if (!rel.startsWith(".")) rel = `./${rel}`;
+	return rel;
+}
+function stripModuleExt(path) {
+	return path.replace(MODULE_EXT_RE, "");
+}
+function addNuxtExplicitImports(ctx) {
+	const { cwd, symbols, toAbs, fromAbs, existingChanges, noScriptError, scan } = ctx;
+	const byPath = new Map(existingChanges.map((change) => [change.path, change]));
+	const aliases = loadNuxtPathAliases(cwd);
+	const consumerSymbols = /* @__PURE__ */ new Map();
+	for (const symbol of symbols) {
+		const hits = scan(symbol, {
+			cwd,
+			kinds: ["identifier-reference"]
+		});
+		for (const hit of hits) {
+			const abs = resolve(cwd, hit.file);
+			if (!consumerSymbols.has(abs)) consumerSymbols.set(abs, /* @__PURE__ */ new Set());
+			consumerSymbols.get(abs).add(symbol);
+		}
+	}
+	const out = [];
+	for (const [filePath, neededSymbols] of consumerSymbols) {
+		if (isGeneratedNuxtPath(cwd, filePath)) continue;
+		if (filePath === fromAbs || filePath === toAbs) continue;
+		let current = byPath.get(filePath)?.after ?? readFileSync(filePath, "utf8");
+		const before = byPath.get(filePath)?.before ?? current;
+		const specifier = resolveBestImportSpecifier(filePath, toAbs, aliases, "./placeholder");
+		let touched = false;
+		for (const symbol of neededSymbols) {
+			if (hasNamedImport(current, symbol)) continue;
+			const next = filePath.endsWith(".vue") ? insertVueScriptImport(current, symbol, specifier, noScriptError) : insertTopLevelImport(current, symbol, specifier);
+			if (next !== current) {
+				current = next;
+				touched = true;
+			}
+		}
+		if (touched) out.push({
+			path: filePath,
+			rel: relative(cwd, filePath),
+			before,
+			after: current
+		});
+	}
+	return out;
+}
+function insertVueScriptImport(source, symbol, specifier, noScriptError) {
+	const match = source.match(/<script(?:\s[^>]*)?>/);
+	if (!match || match.index === void 0) throw noScriptError(symbol);
+	const insertAt = match.index + match[0].length;
+	const scriptEnd = source.indexOf("<\/script>", insertAt);
+	const scriptSource = scriptEnd >= 0 ? source.slice(insertAt, scriptEnd) : source.slice(insertAt);
+	const mergedScript = mergeNamedImport(scriptSource, symbol, specifier);
+	if (mergedScript !== scriptSource) return `${source.slice(0, insertAt)}${mergedScript}${scriptEnd >= 0 ? source.slice(scriptEnd) : ""}`;
+	const rest = source[insertAt] === "\n" ? source.slice(insertAt + 1) : source.slice(insertAt);
+	return `${source.slice(0, insertAt)}\nimport { ${symbol} } from '${specifier}'\n${rest}`;
+}
+function insertTopLevelImport(source, symbol, specifier) {
+	const merged = mergeNamedImport(source, symbol, specifier);
+	if (merged !== source) return merged;
+	const importLine = `import { ${symbol} } from '${specifier}'\n`;
+	if (source.startsWith("#!")) {
+		const nl = source.indexOf("\n");
+		if (nl >= 0) return `${source.slice(0, nl + 1)}${importLine}${source.slice(nl + 1)}`;
+	}
+	return `${importLine}${source}`;
+}
+function hasNamedImport(source, symbol) {
+	const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`\\bimport\\s*\\{[^}]*\\b${escaped}\\b[^}]*\\}\\s*from\\s*['"]`).test(source);
+}
+function mergeNamedImport(source, symbol, specifier) {
+	const spec = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const match = new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*(['"])${spec}\\2`).exec(source);
+	if (!match) return source;
+	const names = match[1].split(",").map((part) => part.trim()).filter(Boolean);
+	if (names.some((name) => name === symbol || name.startsWith(`${symbol} as `))) return source;
+	const replacement = `import { ${[...names, symbol].join(", ")} } from ${match[2]}${specifier}${match[2]}`;
+	return `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`;
+}
+const EXPORT_DECL_RE = /^\s*export\s+(?:async\s+)?(?:function|class|interface|type|enum|const|let|var)\s+([A-Za-z_$][\w$]*)/gm;
+const EXPORT_LIST_RE = /^\s*export\s*\{([^}]+)\}/gm;
+function extractTopLevelExportNames(source) {
+	const out = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(EXPORT_DECL_RE)) out.add(match[1]);
+	for (const match of source.matchAll(EXPORT_LIST_RE)) for (const part of match[1].split(",")) {
+		const cleaned = part.trim();
+		if (!cleaned) continue;
+		const asMatch = cleaned.match(/^(?:type\s+)?[\w$]+\s+as\s+([A-Za-z_$][\w$]*)$/);
+		if (asMatch) {
+			out.add(asMatch[1]);
+			continue;
+		}
+		const direct = cleaned.replace(/^type\s+/, "").match(/^([A-Z_$][\w$]*)$/i);
+		if (direct) out.add(direct[1]);
+	}
+	return [...out];
+}
+const TS_LIKE_RE = /\.(?:tsx?|mts|cts|jsx?|mjs|cjs)$/;
+async function finalizeVueFileRename(cwd, oldAbs, newAbs, existingChanges, autoImportScopes) {
+	const changes = [];
+	const warnings = [];
+	if (oldAbs.endsWith(".vue") && newAbs.endsWith(".vue")) {
+		const oldName = basename(oldAbs, ".vue");
+		const newName = basename(newAbs, ".vue");
+		mergeIntoChanges(changes, rewriteResolveComponentSites(cwd, oldName, newName, existingChanges, oldAbs, newAbs, warnings));
+		if (autoImportScopes.size && isInsideAutoImportScope(oldAbs, autoImportScopes) && !isInsideAutoImportScope(newAbs, autoImportScopes)) mergeIntoChanges(changes, addExplicitComponentImports(cwd, oldName, newName, newAbs, mergeView(existingChanges, changes), oldAbs));
+		return {
+			changes,
+			warnings
+		};
+	}
+	if (TS_LIKE_RE.test(oldAbs) && TS_LIKE_RE.test(newAbs) && autoImportScopes.size && isInsideAutoImportScope(oldAbs, autoImportScopes) && !isInsideAutoImportScope(newAbs, autoImportScopes)) {
+		const movedSource = readMovedSource(oldAbs, newAbs, existingChanges);
+		const symbols = movedSource ? extractTopLevelExportNames(movedSource) : [];
+		if (symbols.length) mergeIntoChanges(changes, addNuxtExplicitImports({
+			cwd,
+			symbols,
+			toAbs: newAbs,
+			fromAbs: oldAbs,
+			existingChanges: mergeView(existingChanges, changes),
+			scan,
+			noScriptError: (name) => /* @__PURE__ */ new Error(`ripast rename-file: "${name}" is auto-imported in Nuxt; moving ${basename(oldAbs)} to ${newAbs} takes it out of auto-import scope but a consumer has no <script> block to receive an explicit import. Add a <script setup> block first, or keep the file in composables/utils.`)
+		}));
+	}
+	return {
+		changes,
+		warnings
+	};
+}
+function readMovedSource(oldAbs, newAbs, existingChanges) {
+	const self = existingChanges.find((c) => c.path === oldAbs || c.path === newAbs);
+	if (self) return self.before;
+	try {
+		return readFileSync(oldAbs, "utf8");
+	} catch {
+		return null;
+	}
+}
+function mergeView(a, b) {
+	const map = /* @__PURE__ */ new Map();
+	for (const c of a) map.set(c.path, c);
+	for (const c of b) map.set(c.path, c);
+	return [...map.values()];
+}
+function mergeIntoChanges(target, incoming) {
+	for (const change of incoming) {
+		const existing = target.find((c) => c.path === change.path);
+		if (existing) existing.after = change.after;
+		else target.push(change);
+	}
+}
+function rewriteResolveComponentSites(cwd, oldName, newName, changes, oldAbs, newAbs, warnings) {
+	const candidates = new Set(rgFiles("resolveComponent", { cwd }));
+	if (!candidates.size) return [];
+	const byPath = new Map(changes.map((change) => [change.path, change]));
+	const escaped = escapeRe(oldName);
+	const literalRe = new RegExp(`resolveComponent\\s*\\(\\s*(['"\`])${escaped}\\1`, "g");
+	const out = [];
+	const warnFiles = [];
+	for (const path of candidates) {
+		if (path === oldAbs || path === newAbs || isGeneratedNuxtPath(cwd, path)) continue;
+		const before = byPath.get(path)?.before ?? readFileSync(path, "utf8");
+		const current = byPath.get(path)?.after ?? before;
+		literalRe.lastIndex = 0;
+		if (!literalRe.test(current)) continue;
+		warnFiles.push(relative(cwd, path));
+		if (oldName === newName) continue;
+		literalRe.lastIndex = 0;
+		const after = current.replace(literalRe, (match, quote) => match.replace(`${quote}${oldName}${quote}`, `${quote}${newName}${quote}`));
+		if (after === current) continue;
+		out.push({
+			path,
+			rel: relative(cwd, path),
+			before,
+			after
+		});
+	}
+	if (warnFiles.length) warnings.push(`rename-file: "${oldName}" is referenced via resolveComponent() in ${warnFiles.length} file(s) [${warnFiles.join(", ")}]. The component must stay globally registered for these sites to resolve (plugin app.component(...) or Nuxt components dir).`);
+	return out;
+}
+function addExplicitComponentImports(cwd, oldName, newName, newAbs, changes, oldAbs) {
+	const tokens = new Set([
+		oldName,
+		newName,
+		hyphenateVueName(oldName),
+		hyphenateVueName(newName)
+	]);
+	const candidates = /* @__PURE__ */ new Set();
+	for (const token of tokens) for (const path of rgFiles(token, {
+		cwd,
+		glob: "*.vue"
+	})) candidates.add(path);
+	if (!candidates.size) return [];
+	const aliases = loadNuxtPathAliases(cwd);
+	const byPath = new Map(changes.map((change) => [change.path, change]));
+	const tagRe = new RegExp(`<\\/?(?:${escapeRe(newName)}|${escapeRe(hyphenateVueName(newName))})(?=[\\s/>])`);
+	const out = [];
+	for (const path of candidates) {
+		if (path === oldAbs || path === newAbs || isGeneratedNuxtPath(cwd, path)) continue;
+		const before = byPath.get(path)?.before ?? readFileSync(path, "utf8");
+		const current = byPath.get(path)?.after ?? before;
+		if (!tagRe.test(current)) continue;
+		if (hasDefaultImportFromVue(current, newName)) continue;
+		const after = insertVueComponentImport(current, newName, resolveBestImportSpecifier(path, newAbs, aliases, "./placeholder.vue"));
+		if (after === current) continue;
+		out.push({
+			path,
+			rel: relative(cwd, path),
+			before,
+			after
+		});
+	}
+	return out;
+}
+function escapeRe(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasDefaultImportFromVue(source, name) {
+	return new RegExp(`\\bimport\\s+${escapeRe(name)}\\s+from\\s+['"\`][^'"\`]+\\.vue['"\`]`).test(source);
+}
+function insertVueComponentImport(source, name, specifier) {
+	const match = source.match(/<script(?:\s[^>]*)?>/);
+	if (!match || match.index === void 0) throw new Error(`ripast rename-file: "${name}" is auto-imported in Nuxt; the new path falls outside auto-import scope but a consumer has no <script> block to receive an explicit import. Add a <script setup> block first.`);
+	const insertAt = match.index + match[0].length;
+	const importLine = `\nimport ${name} from '${specifier}'`;
+	if (source.slice(insertAt, insertAt + 1) === "\n") return `${source.slice(0, insertAt)}${importLine}${source.slice(insertAt)}`;
+	return `${source.slice(0, insertAt)}${importLine}\n${source.slice(insertAt)}`;
+}
 const adapter = {
 	name: "vue",
 	hasFilesContaining: hasVueFilesContaining,
@@ -292,6 +632,15 @@ const adapter = {
 	autoImportScopes(cwd) {
 		if (!isNuxtProject(cwd)) return /* @__PURE__ */ new Set();
 		return nuxtAutoImportScopes(cwd);
+	},
+	isGeneratedPath: isGeneratedNuxtPath,
+	filterGeneratedChanges: removeGeneratedNuxtChanges,
+	addExplicitImports: (ctx) => addNuxtExplicitImports({
+		...ctx,
+		scan
+	}),
+	async finalizeFileRename(cwd, oldAbs, newAbs, existingChanges) {
+		return finalizeVueFileRename(cwd, oldAbs, newAbs, existingChanges, isNuxtProject(cwd) ? nuxtAutoImportScopes(cwd) : /* @__PURE__ */ new Set());
 	}
 };
 const DEFAULT_NUXT_AUTO_IMPORT_DIRS = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripast/vue",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.2.1",
   "description": "Vue (and Nuxt) framework adapter for ripast. Provides Volar/Vue Language Service-backed rename, move, and template rewriting for .vue SFCs.",
   "author": {
     "name": "Harlan Wilton",
@@ -42,7 +42,7 @@
   },
   "peerDependencies": {
     "typescript": ">=5.4",
-    "@ripast/core": "0.0.1"
+    "@ripast/core": "0.2.1"
   },
   "dependencies": {
     "@volar/language-service": "^2.4.28",
@@ -55,7 +55,7 @@
     "vscode-uri": "^3.1.0"
   },
   "devDependencies": {
-    "@ripast/core": "0.0.1"
+    "@ripast/core": "0.2.1"
   },
   "scripts": {
     "build": "obuild",