@ripast/vue 0.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Harlan Wilton <harlan@harlanzw.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { FrameworkAdapter } from "@ripast/core/adapter";
+declare const adapter: FrameworkAdapter;
+export { adapter as default };

package/dist/index.mjs

@@ -0,0 +1,348 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { extractTemplateExpressions, posToLineCol, rewriteTemplateReferences } from "@ripast/core/adapter";
+import { URI } from "vscode-uri";
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+import { FileType, createLanguage, createLanguageService, createUriMap } from "@volar/language-service";
+import { createLanguageServiceHost, resolveFileLanguageId } from "@volar/typescript";
+import { createParsedCommandLine, createVueLanguagePlugin, getAllExtensions } from "@vue/language-core";
+import { createVueLanguageServicePlugins } from "@vue/language-service";
+import ts from "typescript";
+import { create } from "volar-service-typescript";
+import { TextDocument } from "vscode-languageserver-textdocument";
+function createVueService(tsconfigPath, cwd) {
+	const commandLine = createParsedCommandLine(ts, ts.sys, tsconfigPath);
+	const vueExts = getAllExtensions(commandLine.vueOptions).map((ext) => {
+		return {
+			extension: ext.startsWith(".") ? ext.slice(1) : ext,
+			isMixedContent: true,
+			scriptKind: ts.ScriptKind.Deferred
+		};
+	});
+	const fileNames = ts.parseJsonSourceFileConfigFileContent(ts.readJsonConfigFile(tsconfigPath, ts.sys.readFile), ts.sys, resolve(tsconfigPath, ".."), void 0, tsconfigPath, void 0, vueExts).fileNames;
+	if (commandLine.options.allowNonTsExtensions === void 0) commandLine.options.allowNonTsExtensions = true;
+	const fileToUri = (fileName) => URI.file(resolve(cwd, fileName));
+	const uriToFile = (uri) => uri.fsPath;
+	const language = createLanguage([createVueLanguagePlugin(ts, commandLine.options, commandLine.vueOptions, (uri) => uriToFile(uri)), { getLanguageId: (uri) => resolveFileLanguageId(uri.path) }], createUriMap(ts.sys.useCaseSensitiveFileNames), (uri, includeFsFiles) => {
+		if (!includeFsFiles) return;
+		const fileName = uriToFile(uri);
+		if (existsSync(fileName) && statSync(fileName).isFile()) {
+			const text = readFileSync(fileName, "utf8");
+			language.scripts.set(uri, ts.ScriptSnapshot.fromString(text));
+		} else language.scripts.delete(uri);
+	});
+	let projectVersion = 0;
+	const projectHost = {
+		getCurrentDirectory: () => cwd,
+		getCompilationSettings: () => commandLine.options,
+		getProjectReferences: () => commandLine.projectReferences,
+		getScriptFileNames: () => fileNames.map((f) => resolve(cwd, f)),
+		getProjectVersion: () => String(projectVersion)
+	};
+	const env = {
+		workspaceFolders: [URI.file(cwd)],
+		fs: {
+			stat(uri) {
+				if (uri.scheme !== "file") return void 0;
+				try {
+					const s = statSync(uri.fsPath);
+					return {
+						type: s.isFile() ? FileType.File : s.isDirectory() ? FileType.Directory : s.isSymbolicLink() ? FileType.SymbolicLink : FileType.Unknown,
+						ctime: s.ctimeMs,
+						mtime: s.mtimeMs,
+						size: s.size
+					};
+				} catch {
+					return;
+				}
+			},
+			readFile(uri) {
+				if (uri.scheme !== "file") return void 0;
+				try {
+					return readFileSync(uri.fsPath, "utf8");
+				} catch {
+					return;
+				}
+			},
+			readDirectory() {
+				return [];
+			}
+		},
+		console: {
+			log() {},
+			warn() {},
+			error: process.stderr.write.bind(process.stderr),
+			info() {}
+		}
+	};
+	const project = { typescript: {
+		configFileName: tsconfigPath,
+		sys: ts.sys,
+		uriConverter: {
+			asFileName: uriToFile,
+			asUri: fileToUri
+		},
+		...createLanguageServiceHost(ts, ts.sys, language, fileToUri, projectHost)
+	} };
+	const service = createLanguageService(language, [...create(ts), ...createVueLanguageServicePlugins(ts)], env, project);
+	return {
+		service,
+		fileToUri,
+		uriToFile,
+		read: (fileName) => {
+			try {
+				return readFileSync(fileName, "utf8");
+			} catch {
+				return;
+			}
+		},
+		setSnapshot: (fileName, text) => {
+			language.scripts.set(URI.file(resolve(cwd, fileName)), ts.ScriptSnapshot.fromString(text));
+			projectVersion++;
+		},
+		dispose: () => service.dispose()
+	};
+}
+function workspaceEditToChanges(edit, vue, cwd, filter) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const apply = (uriStr, edits) => {
+		const fileName = URI.parse(uriStr).fsPath;
+		if (filter && !filter(fileName)) return;
+		if (seen.has(fileName)) return;
+		seen.add(fileName);
+		const before = vue.read(fileName);
+		if (before === void 0) return;
+		const doc = TextDocument.create(uriStr, "plaintext", 0, before);
+		const after = TextDocument.applyEdits(doc, edits);
+		if (after === before) return;
+		out.push({
+			path: fileName,
+			rel: relPath$1(fileName, cwd),
+			before,
+			after
+		});
+	};
+	if (edit.changes) for (const [uriStr, edits] of Object.entries(edit.changes)) apply(uriStr, edits);
+	if (edit.documentChanges) {
+		for (const change of edit.documentChanges) if ("textDocument" in change && "edits" in change) apply(change.textDocument.uri, change.edits);
+	}
+	return out;
+}
+function relPath$1(fileName, cwd) {
+	return fileName.startsWith(cwd) ? fileName.slice(cwd.length).replace(/^[/\\]/, "") : fileName;
+}
+function hasVueFilesContaining(cwd, pattern) {
+	return !!spawnSync("rg", [
+		"--files-with-matches",
+		"--hidden",
+		"--no-messages",
+		"--fixed-strings",
+		"-g",
+		"*.vue",
+		pattern,
+		"."
+	], {
+		cwd,
+		encoding: "utf8"
+	}).stdout.trim();
+}
+async function applyVueRename(tsconfigPath, cwd, from, to, sites) {
+	const vue = createVueService(tsconfigPath, cwd);
+	try {
+		const byPath = /* @__PURE__ */ new Map();
+		for (const site of sites) {
+			const uri = URI.file(resolve(cwd, site.filePath));
+			const { line, col } = posToLineCol(site.source, site.pos);
+			const edits = await vue.service.getRenameEdits(uri, {
+				line: line - 1,
+				character: col - 1
+			}, to);
+			if (!edits) continue;
+			const vueChanges = workspaceEditToChanges(edits, vue, cwd, (fileName) => fileName.endsWith(".vue"));
+			for (const c of vueChanges) {
+				if (byPath.has(c.path)) continue;
+				byPath.set(c.path, c);
+			}
+		}
+		const consumerPaths = new Set(byPath.keys());
+		for (const p of listVueFilesContaining(cwd, from)) consumerPaths.add(p);
+		for (const path of consumerPaths) {
+			const existing = byPath.get(path);
+			const before = existing?.before ?? safeReadFile(path);
+			if (before === void 0) continue;
+			const baseAfter = existing?.after ?? before;
+			const rewritten = rewriteTemplateReferences(baseAfter, from, to);
+			if (rewritten === baseAfter) continue;
+			byPath.set(path, {
+				path,
+				rel: existing?.rel ?? relPath(path, cwd),
+				before,
+				after: rewritten
+			});
+		}
+		return [...byPath.values()];
+	} finally {
+		vue.dispose();
+	}
+}
+function listVueFilesContaining(cwd, pattern) {
+	return spawnSync("rg", [
+		"--files-with-matches",
+		"--hidden",
+		"--no-messages",
+		"--fixed-strings",
+		"-g",
+		"*.vue",
+		pattern,
+		"."
+	], {
+		cwd,
+		encoding: "utf8"
+	}).stdout.split("\n").filter(Boolean).map((p) => resolve(cwd, p));
+}
+function safeReadFile(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return;
+	}
+}
+function relPath(fileName, cwd) {
+	return fileName.startsWith(cwd) ? fileName.slice(cwd.length).replace(/^[/\\]/, "") : fileName;
+}
+async function applyVueImportRewrite(tsconfigPath, cwd, fromAbs, toAbs) {
+	const vue = createVueService(tsconfigPath, cwd);
+	try {
+		const oldUri = URI.file(fromAbs);
+		const newUri = URI.file(toAbs);
+		const edits = await vue.service.getFileRenameEdits(oldUri, newUri);
+		if (!edits) return [];
+		return workspaceEditToChanges(edits, vue, cwd, (fileName) => fileName.endsWith(".vue"));
+	} finally {
+		vue.dispose();
+	}
+}
+async function vueRegressions(tsconfigPath, cwd, pendingChanges) {
+	const vueFiles = listVueFiles(cwd);
+	if (!vueFiles.length) return [];
+	const vue = createVueService(tsconfigPath, cwd);
+	try {
+		const baselinePairs = await Promise.all(vueFiles.map(async (file) => [file, await collectDiagKeys(vue, file)]));
+		const baseline = new Map(baselinePairs);
+		for (const c of pendingChanges) vue.setSnapshot(c.path, c.after);
+		const checkSet = [...new Set([...vueFiles, ...pendingChanges.filter((c) => c.path.endsWith(".vue")).map((c) => c.path)])];
+		const postPairs = await Promise.all(checkSet.map(async (file) => [file, await getDiags(vue, file)]));
+		const out = [];
+		for (const [file, post] of postPairs) {
+			const before = baseline.get(file) ?? /* @__PURE__ */ new Set();
+			for (const d of post) {
+				const key = diagKey(d);
+				if (before.has(key)) continue;
+				if (d.severity !== 1) continue;
+				out.push({
+					file,
+					line: d.range.start.line + 1,
+					col: d.range.start.character + 1,
+					code: typeof d.code === "number" ? d.code : 0,
+					message: typeof d.message === "string" ? d.message : String(d.message)
+				});
+			}
+		}
+		return out;
+	} finally {
+		vue.dispose();
+	}
+}
+async function collectDiagKeys(vue, fileName) {
+	const diags = await getDiags(vue, fileName);
+	return new Set(diags.map(diagKey));
+}
+async function getDiags(vue, fileName) {
+	const uri = URI.file(fileName);
+	return await vue.service.getDiagnostics(uri);
+}
+function diagKey(d) {
+	return `${d.range.start.line}:${d.range.start.character}:${d.code ?? ""}:${d.message}`;
+}
+function listVueFiles(cwd) {
+	return spawnSync("rg", [
+		"--files",
+		"--hidden",
+		"--no-messages",
+		"-g",
+		"*.vue",
+		"."
+	], {
+		cwd,
+		encoding: "utf8"
+	}).stdout.split("\n").filter(Boolean).map((p) => resolve(cwd, p));
+}
+const adapter = {
+	name: "vue",
+	hasFilesContaining: hasVueFilesContaining,
+	applyRename: applyVueRename,
+	applyImportRewrite: applyVueImportRewrite,
+	regressions: vueRegressions,
+	extractTemplateExpressions,
+	async applyFileRenameEdits(tsconfigPath, cwd, oldAbs, newAbs) {
+		const vue = createVueService(tsconfigPath, cwd);
+		try {
+			const edits = await vue.service.getFileRenameEdits(URI.file(oldAbs), URI.file(newAbs));
+			return edits ? workspaceEditToChanges(edits, vue, cwd) : [];
+		} finally {
+			vue.dispose();
+		}
+	},
+	autoImportScopes(cwd) {
+		if (!isNuxtProject(cwd)) return /* @__PURE__ */ new Set();
+		return nuxtAutoImportScopes(cwd);
+	}
+};
+const DEFAULT_NUXT_AUTO_IMPORT_DIRS = [
+	"composables",
+	"utils",
+	"components",
+	"server/utils",
+	"middleware"
+];
+function isNuxtProject(cwd) {
+	if (existsSync(join(cwd, "nuxt.config.ts")) || existsSync(join(cwd, "nuxt.config.js")) || existsSync(join(cwd, ".nuxt"))) return true;
+	const pkgPath = join(cwd, "package.json");
+	if (!existsSync(pkgPath)) return false;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		const deps = {
+			...pkg.dependencies,
+			...pkg.devDependencies,
+			...pkg.peerDependencies
+		};
+		return Boolean(deps.nuxt || deps["@nuxt/kit"]);
+	} catch {
+		return false;
+	}
+}
+function nuxtAutoImportScopes(cwd) {
+	const dirs = new Set(DEFAULT_NUXT_AUTO_IMPORT_DIRS);
+	const configPath = [
+		"nuxt.config.ts",
+		"nuxt.config.js",
+		"nuxt.config.mjs",
+		"nuxt.config.mts"
+	].map((name) => join(cwd, name)).find((path) => existsSync(path));
+	if (configPath) try {
+		for (const dir of extractConfiguredDirs(readFileSync(configPath, "utf8"))) dirs.add(dir);
+	} catch {}
+	return new Set([...dirs].map((dir) => resolve(cwd, stripGlob(dir))));
+}
+function extractConfiguredDirs(source) {
+	const dirs = [];
+	for (const match of source.matchAll(/\bdirs\s*:\s*\[([\s\S]*?)\]/g)) for (const str of match[1].matchAll(/['"`]([^'"`]+)['"`]/g)) dirs.push(str[1]);
+	for (const match of source.matchAll(/\bcomponents\s*:\s*\[([\s\S]*?)\]/g)) for (const str of match[1].matchAll(/(?:path\s*:\s*)?['"`]([^'"`]+)['"`]/g)) dirs.push(str[1]);
+	return dirs.filter((dir) => !dir.startsWith("#") && !dir.startsWith("~") && !dir.startsWith("@"));
+}
+function stripGlob(dir) {
+	return dir.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "");
+}
+export { adapter as default };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@ripast/vue",
+  "type": "module",
+  "version": "0.0.0",
+  "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",
+    "email": "harlan@harlanzw.com",
+    "url": "https://harlanzw.com/"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/harlan-zw/ripast#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harlan-zw/ripast.git",
+    "directory": "packages/vue"
+  },
+  "bugs": {
+    "url": "https://github.com/harlan-zw/ripast/issues"
+  },
+  "keywords": [
+    "ripast",
+    "vue",
+    "nuxt",
+    "volar",
+    "ast",
+    "refactor"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.11"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.4",
+    "@ripast/core": "0.0.0"
+  },
+  "dependencies": {
+    "@volar/language-service": "^2.4.28",
+    "@volar/typescript": "^2.4.28",
+    "@vue/language-core": "^3.2.8",
+    "@vue/language-service": "^3.2.8",
+    "volar-service-typescript": "^0.0.71",
+    "vscode-languageserver-protocol": "3.17.5",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "vscode-uri": "^3.1.0"
+  },
+  "devDependencies": {
+    "@ripast/core": "0.0.0"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev:prepare": "obuild --stub"
+  }
+}