@dxup/nuxt 0.1.0 → 0.2.0

package/README.md

@@ -9,6 +9,7 @@ This is a TypeScript plugin that improves Nuxt DX.
 ## Features
 
 - Update references when renaming auto imported component files
+- Go to definition for dynamic imports with glob patterns
 - Go to definition for nitro routes in data fetching methods
 - Go to definition for runtime config
 - [@dxup/unimport](/packages/unimport)

package/dist/module.d.ts

@@ -2,10 +2,33 @@ import * as _nuxt_schema0 from "@nuxt/schema";
 
 //#region src/module/index.d.ts
 interface ModuleOptions {
-  components?: boolean;
-  nitroRoutes?: boolean;
-  runtimeConfig?: boolean;
-  unimport?: boolean;
+  features?: {
+    /**
+     * Whether to update references when renaming auto imported component files.
+     * @default true
+     */
+    components?: boolean;
+    /**
+     * Whether to enable Go to Definition for dynamic imports with glob patterns.
+     * @default true
+     */
+    importGlob?: boolean;
+    /**
+     * Whether to enable Go to Definition for nitro routes in data fetching methods.
+     * @default true
+     */
+    nitroRoutes?: boolean;
+    /**
+     * Whether to enable Go to Definition for runtime config.
+     * @default true
+     */
+    runtimeConfig?: boolean;
+    /**
+     * Whether to enable enhanced navigation for auto imported APIs.
+     * @default true
+     */
+    unimport?: boolean;
+  };
 }
 declare const _default: _nuxt_schema0.NuxtModule<ModuleOptions, ModuleOptions, false>;
 //#endregion

package/dist/module.js

@@ -1,4 +1,4 @@
-import { addTemplate, defineNuxtModule } from "@nuxt/kit";
+import { addTemplate, defineNuxtModule, useNitro } from "@nuxt/kit";
 import { Buffer } from "node:buffer";
 import EventEmitter from "node:events";
 import { mkdir, open, readFile, writeFile } from "node:fs/promises";
@@ -69,15 +69,16 @@ var module_default = defineNuxtModule({
 		name,
 		configKey: "dxup"
 	},
-	defaults: {
+	defaults: { features: {
 		components: true,
+		importGlob: true,
 		nitroRoutes: true,
 		runtimeConfig: true,
 		unimport: true
-	},
+	} },
 	async setup(options, nuxt) {
 		const pluginsTs = [{ name: "@dxup/nuxt" }];
-		if (options.unimport) pluginsTs.unshift({ name: "@dxup/unimport" });
+		if (options.features?.unimport) pluginsTs.unshift({ name: "@dxup/unimport" });
 		append(pluginsTs, nuxt.options, "typescript", "tsConfig", "compilerOptions");
 		append(pluginsTs, nuxt.options.nitro, "typescript", "tsConfig", "compilerOptions");
 		append(pluginsTs, nuxt.options, "typescript", "sharedTsConfig", "compilerOptions");
@@ -85,14 +86,16 @@ var module_default = defineNuxtModule({
 		addTemplate({
 			filename: "dxup/data.json",
 			write: true,
-			getContents() {
+			getContents({ nuxt: nuxt$1 }) {
+				const nitro = useNitro();
+				const nitroRoutes = options.features?.nitroRoutes && Object.fromEntries(nitro.scannedHandlers.filter((item) => item.route).map((item) => [`${item.route}+${item.method ?? "get"}`, item.handler]));
 				const data = {
-					buildDir: nuxt.options.buildDir,
-					serverDir: nuxt.options.serverDir,
-					configFiles: [...nuxt.options._nuxtConfigFiles, ...nuxt.options._layers.map((layer) => layer._configFile).filter(Boolean)],
-					components: options.components,
-					nitroRoutes: options.nitroRoutes,
-					runtimeConfig: options.runtimeConfig
+					buildDir: nuxt$1.options.buildDir,
+					configFiles: [...nuxt$1.options._nuxtConfigFiles, ...nuxt$1.options._layers.map((layer) => layer._configFile).filter(Boolean)],
+					components: options.features?.components,
+					importGlob: options.features?.importGlob,
+					nitroRoutes,
+					runtimeConfig: options.features?.runtimeConfig
 				};
 				return JSON.stringify(data, null, 2);
 			}

package/dist/typescript.cjs

@@ -25,6 +25,8 @@ let pathe = require("pathe");
 pathe = __toESM(pathe);
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
+let tinyglobby = require("tinyglobby");
+tinyglobby = __toESM(tinyglobby);
 
 //#region src/event/server.ts
 function createEventServer(info) {
@@ -63,10 +65,8 @@ function* binaryVisit(ts, sourceFile, node, position) {
 	while (left <= right) {
 		const mid = Math.floor((left + right) / 2);
 		const node$1 = nodes[mid];
-		const start = node$1.getStart(sourceFile);
-		const end = node$1.getEnd();
-		if (position < start) right = mid - 1;
-		else if (position > end) left = mid + 1;
+		if (position > node$1.getEnd()) left = mid + 1;
+		else if (position < node$1.getStart(sourceFile)) right = mid - 1;
 		else {
 			yield node$1;
 			yield* binaryVisit(ts, sourceFile, node$1, position);
@@ -74,6 +74,9 @@ function* binaryVisit(ts, sourceFile, node, position) {
 		}
 	}
 }
+function isTextSpanEqual(node, textSpan, sourceFile) {
+	return textSpan.start + textSpan.length === node.getEnd() && textSpan.start === node.getStart(sourceFile);
+}
 
 //#endregion
 //#region src/typescript/features/getDefinitionAndBoundSpan.ts
@@ -82,49 +85,21 @@ const fetchFunctions = new Set([
 	"useFetch",
 	"useLazyFetch"
 ]);
-const nonApiRE = /^(?!\/api\/)/;
 function getDefinitionAndBoundSpan(context, getDefinitionAndBoundSpan$1) {
 	const { ts, info, data } = context;
 	return (...args) => {
 		const result = getDefinitionAndBoundSpan$1(...args);
-		if (!result && data.nitroRoutes) {
+		if (!result) {
 			const program$1 = info.languageService.getProgram();
 			const sourceFile = program$1.getSourceFile(args[0]);
 			if (!sourceFile) return;
 			const checker = program$1.getTypeChecker();
+			let res;
 			for (const node of forEachTouchingNode(ts, sourceFile, args[1])) {
-				if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression) || !fetchFunctions.has(node.expression.text) || !node.arguments.length) continue;
-				const firstArg = node.arguments[0];
-				const start = firstArg.getStart(sourceFile);
-				const end = firstArg.getEnd();
-				if (args[1] < start || args[1] > end) continue;
-				const resolvedSignature = checker.getResolvedSignature(node);
-				if (!resolvedSignature) break;
-				const typeArguments = checker.getTypeArgumentsForResolvedSignature(resolvedSignature);
-				const [routeType, methodType] = (node.expression.text === "$fetch" ? typeArguments?.[2] && checker.getTypeArguments(typeArguments?.[2]) : typeArguments?.slice(2)) ?? [];
-				if (!routeType?.isStringLiteral() || !methodType?.isStringLiteral()) break;
-				const route = routeType.value.replace(nonApiRE, "/routes");
-				const method = methodType.value;
-				const path = (0, pathe.join)(data.serverDir, `${route}.${method}.ts`);
-				return {
-					textSpan: {
-						start,
-						length: end - start
-					},
-					definitions: [{
-						fileName: path,
-						textSpan: {
-							start: 0,
-							length: 0
-						},
-						kind: ts.ScriptElementKind.scriptElement,
-						name: path,
-						containerKind: ts.ScriptElementKind.unknown,
-						containerName: ""
-					}]
-				};
+				if (data.importGlob) res ??= visitImportGlob(ts, info, sourceFile, node, args[1]);
+				if (data.nitroRoutes) res ??= visitNitroRoutes(ts, checker, sourceFile, node, args[1], data.nitroRoutes);
 			}
-			return;
+			if (res) return res;
 		}
 		if (!result?.definitions?.length) return result;
 		const program = info.languageService.getProgram();
@@ -145,6 +120,88 @@ function getDefinitionAndBoundSpan(context, getDefinitionAndBoundSpan$1) {
 		};
 	};
 }
+function visitImportGlob(ts, info, sourceFile, node, position) {
+	if (!ts.isCallExpression(node) || !node.arguments.length) return;
+	const firstArg = node.arguments[0];
+	const start = firstArg.getStart(sourceFile);
+	const end = firstArg.getEnd();
+	if (position < start || position > end) return;
+	let pattern;
+	const callText = node.expression.getText(sourceFile);
+	if (callText === "import" && ts.isTemplateExpression(firstArg)) pattern = [firstArg.head.text, ...firstArg.templateSpans.map((span) => span.literal.text)].join("*");
+	else if (callText === "import.meta.glob" && ts.isStringLiteral(firstArg)) pattern = firstArg.text;
+	if (pattern === void 0) return;
+	const resolved = ts.resolveModuleName(pattern, sourceFile.fileName, info.languageServiceHost.getCompilationSettings(), {
+		fileExists: () => true,
+		readFile: () => ""
+	});
+	if (!resolved?.resolvedModule) return;
+	const extension = (0, pathe.extname)(pattern);
+	const arbitrary = `.d${extension}.ts`;
+	pattern = resolved.resolvedModule.resolvedFileName;
+	if (resolved.resolvedModule.extension === arbitrary) pattern = pattern.slice(0, -arbitrary.length) + extension;
+	const fileNames = (0, tinyglobby.globSync)(pattern, { absolute: true });
+	return {
+		textSpan: {
+			start,
+			length: end - start
+		},
+		definitions: fileNames.map((fileName) => ({
+			fileName,
+			textSpan: {
+				start: 0,
+				length: 0
+			},
+			kind: ts.ScriptElementKind.unknown,
+			name: fileName,
+			containerKind: ts.ScriptElementKind.unknown,
+			containerName: ""
+		}))
+	};
+}
+function visitNitroRoutes(ts, checker, sourceFile, node, position, nitroRoutes) {
+	if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression) || !fetchFunctions.has(node.expression.text) || !node.arguments.length) return;
+	const firstArg = node.arguments[0];
+	const start = firstArg.getStart(sourceFile);
+	const end = firstArg.getEnd();
+	if (position < start || position > end) return;
+	const resolvedSignature = checker.getResolvedSignature(node);
+	if (!resolvedSignature) return;
+	const typeArguments = checker.getTypeArgumentsForResolvedSignature(resolvedSignature);
+	let routeType;
+	let methodType;
+	if (node.expression.text === "$fetch") {
+		routeType = typeArguments?.[1];
+		const symbol = typeArguments?.[2].getProperty("method");
+		methodType = symbol ? checker.getTypeOfSymbol(symbol) : void 0;
+	} else {
+		routeType = typeArguments?.[2];
+		methodType = typeArguments?.[3];
+	}
+	if (!routeType?.isStringLiteral()) return;
+	const paths = [];
+	for (const type of methodType?.isUnion() ? methodType.types : [methodType]) if (type?.isStringLiteral()) {
+		const path = nitroRoutes[`${routeType.value}+${type.value}`];
+		if (path !== void 0) paths.push(path);
+	}
+	return {
+		textSpan: {
+			start,
+			length: end - start
+		},
+		definitions: paths.map((path) => ({
+			fileName: path,
+			textSpan: {
+				start: 0,
+				length: 0
+			},
+			kind: ts.ScriptElementKind.scriptElement,
+			name: path,
+			containerKind: ts.ScriptElementKind.unknown,
+			containerName: ""
+		}))
+	};
+}
 function visitRuntimeConfig(context, sourceFile, definition) {
 	const { ts } = context;
 	let definitions = [];
@@ -154,10 +211,7 @@ function visitRuntimeConfig(context, sourceFile, definition) {
 		if (ts.isInterfaceDeclaration(node) && ts.isIdentifier(node.name)) key = node.name.text;
 		else if (ts.isPropertySignature(node) && ts.isIdentifier(node.name)) {
 			key = node.name.text;
-			const { textSpan } = definition;
-			const start = node.name.getStart(sourceFile);
-			const end = node.name.getEnd();
-			if (start === textSpan.start && end - start === textSpan.length) {
+			if (isTextSpanEqual(node.name, definition.textSpan, sourceFile)) {
 				path.push(key);
 				definitions = [...forwardRuntimeConfig(context, definition, path)];
 				break;
@@ -280,36 +334,49 @@ function getEditsForFileRename(context, getEditsForFileRename$1) {
 const plugin = (module$1) => {
 	const { typescript: ts } = module$1;
 	return { create(info) {
-		const currentDirectory = info.languageServiceHost.getCurrentDirectory();
-		const path = (0, pathe.join)(currentDirectory, "dxup/data.json");
 		const context = {
 			ts,
 			info,
-			data: {
-				buildDir: currentDirectory,
-				configFiles: [],
-				components: true,
-				nitroRoutes: true,
-				runtimeConfig: true,
-				...JSON.parse(ts.sys.readFile(path) ?? "{}")
-			},
+			data: createData(ts, info),
 			server: createEventServer(info)
 		};
 		setTimeout(() => {
 			context.language = (info.project.__vue__ ?? info.project["program"]?.__vue__)?.language;
 		}, 500);
 		for (const [key, method] of [
-			["findRenameLocations", findRenameLocations.bind(null, context)],
-			["getDefinitionAndBoundSpan", getDefinitionAndBoundSpan.bind(null, context)],
-			["getEditsForFileRename", getEditsForFileRename.bind(null, context)]
+			["findRenameLocations", findRenameLocations],
+			["getDefinitionAndBoundSpan", getDefinitionAndBoundSpan],
+			["getEditsForFileRename", getEditsForFileRename]
 		]) {
 			const original = info.languageService[key];
-			info.languageService[key] = method(original);
+			info.languageService[key] = method(context, original);
 		}
 		return info.languageService;
 	} };
 };
 var typescript_default = plugin;
+function createData(ts, info) {
+	const initialValue = {
+		buildDir: "",
+		configFiles: [],
+		components: true,
+		importGlob: true,
+		nitroRoutes: {},
+		runtimeConfig: true
+	};
+	const path = (0, pathe.join)(info.languageServiceHost.getCurrentDirectory(), "dxup/data.json");
+	const data = {};
+	update();
+	ts.sys.watchFile?.(path, update);
+	return data;
+	function update() {
+		const text = ts.sys.readFile(path);
+		Object.assign(data, {
+			...initialValue,
+			...text ? JSON.parse(text) : {}
+		});
+	}
+}
 
 //#endregion
 module.exports = typescript_default;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxup/nuxt",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "TypeScript plugin for Nuxt",
   "author": "KazariEX",
   "license": "MIT",
@@ -19,6 +19,7 @@
     "@nuxt/kit": "^4.1.3",
     "chokidar": "^4.0.3",
     "pathe": "2.0.3",
+    "tinyglobby": "^0.2.15",
     "@dxup/unimport": "^0.1.0"
   },
   "devDependencies": {