@analogjs/language-server 0.2.1 → 0.2.4

package/out/plugins/routingPlugin.d.ts

@@ -2,6 +2,7 @@ import type { LanguageServicePlugin } from '@volar/language-service';
 import type { RouteScanner } from '../routeScanner';
 /**
  * Creates a Volar language service plugin that provides
- * route path completions and go-to-definition for Analog's file-based routing.
+ * route path completions, document links, and go-to-definition
+ * for Analog's file-based routing.
  */
 export declare function createRoutingPlugin(scanner: RouteScanner): LanguageServicePlugin;

package/out/plugins/routingPlugin.js

@@ -28,57 +28,107 @@ const vscode = __importStar(require("vscode-languageserver-protocol"));
 const vscode_uri_1 = require("vscode-uri");
 /**
  * Check if a position is inside a string literal and return the string content.
- * Handles both single and double quoted strings.
+ * Handles single quotes, double quotes, and backtick template literals.
  */
 function getStringAtPosition(document, position) {
     const line = document.getText(vscode.Range.create(position.line, 0, position.line + 1, 0));
     const offset = position.character;
-    // Find the string boundaries around the cursor
-    let start = -1;
-    let end = -1;
-    let quote = '';
-    for (let i = offset - 1; i >= 0; i--) {
-        if ((line[i] === '"' || line[i] === "'") && (i === 0 || line[i - 1] !== '\\')) {
-            start = i;
-            quote = line[i];
-            break;
+    const quotes = ['"', "'", '`'];
+    let bestMatch;
+    for (const quote of quotes) {
+        let start = -1;
+        let end = -1;
+        for (let i = offset - 1; i >= 0; i--) {
+            if (line[i] === quote && (i === 0 || line[i - 1] !== '\\')) {
+                start = i;
+                break;
+            }
         }
-    }
-    if (start === -1 || !quote)
-        return undefined;
-    for (let i = offset; i < line.length; i++) {
-        if (line[i] === quote && line[i - 1] !== '\\') {
-            end = i;
-            break;
+        if (start === -1)
+            continue;
+        for (let i = offset; i < line.length; i++) {
+            if (line[i] === quote && line[i - 1] !== '\\') {
+                end = i;
+                break;
+            }
+        }
+        if (end === -1)
+            continue;
+        if (!bestMatch || start > bestMatch.start) {
+            const value = line.substring(start + 1, end);
+            const range = vscode.Range.create(position.line, start + 1, position.line, end);
+            bestMatch = { value, range, start };
         }
     }
-    if (end === -1)
-        return undefined;
-    const value = line.substring(start + 1, end);
-    const range = vscode.Range.create(position.line, start + 1, position.line, end);
-    return { value, range };
+    return bestMatch;
 }
 /**
  * Check if the string at position is in a routing context.
- * Looks for routerLink, navigate, navigateByUrl, route(), etc.
  */
 function isRoutingContext(document, position) {
     const line = document.getText(vscode.Range.create(position.line, 0, position.line + 1, 0));
-    // Check for common routing patterns in the line
-    return /routerLink|\.navigate\(|\.navigateByUrl\(|route\(|injectNavigate|injectNavigateByUrl|routerLink\s*=/.test(line);
+    return /routerLink|\.navigate\(|\.navigateByUrl\(|route\(|injectNavigate|injectNavigateByUrl/.test(line);
+}
+/**
+ * Extract a file system path from a document URI.
+ */
+function getDocumentFsPath(document) {
+    const uri = vscode_uri_1.URI.parse(document.uri);
+    if (uri.scheme === 'file') {
+        return uri.fsPath;
+    }
+    if (uri.scheme === 'angular-embedded-content') {
+        const decoded = decodeURIComponent(uri.path);
+        const match = decoded.match(/file:\/\/(.+?)(?:\.html|\.css)?$/);
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+/**
+ * Find all route-path strings in a document and return their ranges and values.
+ */
+function findRouteStrings(document) {
+    const text = document.getText();
+    const results = [];
+    // Match routerLink="..." routerLink='...' [routerLink]="'...'"
+    const patterns = [
+        /routerLink\s*=\s*"(\/[^"]*)"/g,
+        /routerLink\s*=\s*'(\/[^']*)'/g,
+        /\[routerLink\]\s*=\s*"'(\/[^']*)'"/g,
+        /\[routerLink\]\s*=\s*"\"(\/[^\"]*)\""/g,
+        /\.navigateByUrl\(\s*['"](\/[^'"]*)['"]/g,
+        /route\(\s*['"](\/[^'"]*)['"]/g,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            const value = match[1];
+            const valueStart = match.index + match[0].indexOf(value);
+            const startPos = document.positionAt(valueStart);
+            const endPos = document.positionAt(valueStart + value.length);
+            results.push({
+                value,
+                range: vscode.Range.create(startPos, endPos),
+            });
+        }
+    }
+    return results;
 }
 /**
  * Creates a Volar language service plugin that provides
- * route path completions and go-to-definition for Analog's file-based routing.
+ * route path completions, document links, and go-to-definition
+ * for Analog's file-based routing.
  */
 function createRoutingPlugin(scanner) {
     return {
         name: 'analog-routing',
         capabilities: {
             completionProvider: {
-                triggerCharacters: ["'", '"', '/'],
+                triggerCharacters: ["'", '"', '/', '`'],
             },
             definitionProvider: true,
+            documentLinkProvider: {},
         },
         create() {
             return {
@@ -89,17 +139,33 @@ function createRoutingPlugin(scanner) {
                     const stringInfo = getStringAtPosition(document, position);
                     if (!stringInfo)
                         return undefined;
-                    const routes = scanner.getRoutes();
+                    const documentPath = getDocumentFsPath(document);
+                    const routes = scanner.getRoutes(documentPath);
                     if (routes.length === 0)
                         return undefined;
                     const items = routes
                         .filter((route) => !route.isCatchAll)
                         .map((route) => {
+                        const hasParams = route.params.length > 0;
+                        let insertText;
+                        if (hasParams) {
+                            // Convert :param to ${N:param} snippet tab stops
+                            let tabIndex = 1;
+                            insertText = route.urlPath.replace(/:([^/]+)/g, () => {
+                                const param = route.params[tabIndex - 1] || 'value';
+                                return `\${${tabIndex++}:${param}}`;
+                            });
+                        }
+                        else {
+                            insertText = route.urlPath;
+                        }
                         const item = {
                             label: route.urlPath,
                             kind: vscode.CompletionItemKind.File,
                             detail: route.filePath.replace(/^.*\/src\//, 'src/'),
-                            sortText: route.params.length > 0 ? '1' : '0',
+                            sortText: hasParams ? '1' : '0',
+                            insertTextFormat: hasParams ? 2 : 1,
+                            textEdit: vscode.TextEdit.replace(stringInfo.range, insertText),
                         };
                         if (route.params.length > 0) {
                             item.documentation = {
@@ -127,6 +193,24 @@ function createRoutingPlugin(scanner) {
                         items,
                     };
                 },
+                provideDocumentLinks(document) {
+                    const documentPath = getDocumentFsPath(document);
+                    const routeStrings = findRouteStrings(document);
+                    if (routeStrings.length === 0)
+                        return undefined;
+                    const links = [];
+                    for (const { value, range } of routeStrings) {
+                        const matches = scanner.findByUrlString(value, documentPath);
+                        if (matches.length > 0) {
+                            links.push({
+                                range,
+                                target: vscode_uri_1.URI.file(matches[0].filePath).toString(),
+                                tooltip: `Go to ${matches[0].filePath.replace(/^.*\/src\//, 'src/')}`,
+                            });
+                        }
+                    }
+                    return links;
+                },
                 provideDefinition(document, position) {
                     const stringInfo = getStringAtPosition(document, position);
                     if (!stringInfo)
@@ -134,10 +218,16 @@ function createRoutingPlugin(scanner) {
                     const value = stringInfo.value;
                     if (!value.startsWith('/'))
                         return undefined;
-                    const matches = scanner.findByUrlString(value);
+                    const documentPath = getDocumentFsPath(document);
+                    const matches = scanner.findByUrlString(value, documentPath);
                     if (matches.length === 0)
                         return undefined;
-                    return matches.map((route) => vscode.LocationLink.create(vscode_uri_1.URI.file(route.filePath).toString(), vscode.Range.create(0, 0, 0, 0), vscode.Range.create(0, 0, 0, 0), stringInfo.range));
+                    return matches.map((route) => ({
+                        targetUri: vscode_uri_1.URI.file(route.filePath).toString(),
+                        targetRange: vscode.Range.create(0, 0, 0, 0),
+                        targetSelectionRange: vscode.Range.create(0, 0, 0, 0),
+                        originSelectionRange: stringInfo.range,
+                    }));
                 },
             };
         },

package/out/routeScanner.d.ts

@@ -11,31 +11,37 @@ export interface RouteInfo {
     isCatchAll: boolean;
 }
 /**
- * Scans the workspace for Analog page files and builds a route map.
+ * Scans the workspace for Analog page files and builds a route map,
+ * grouped by project so monorepo routes are scoped correctly.
  */
 export declare class RouteScanner {
-    private routes;
+    private projects;
     private workspaceRoot;
     constructor(workspaceRoot: string);
     /**
-     * Perform initial scan of the pages directory.
+     * Perform initial scan of all pages directories in the workspace.
      */
     scan(): void;
     /**
-     * Get all discovered routes.
+     * Determine which project a document belongs to based on its file path.
      */
-    getRoutes(): RouteInfo[];
+    private getProjectForFile;
     /**
-     * Find a route by its URL path.
+     * Get routes scoped to the project containing the given document.
+     * Falls back to all routes if no project match is found.
      */
-    findByUrlPath(urlPath: string): RouteInfo | undefined;
+    getRoutes(documentPath?: string): RouteInfo[];
+    /**
+     * Find a route by its URL path, scoped to the document's project.
+     */
+    findByUrlPath(urlPath: string, documentPath?: string): RouteInfo | undefined;
     /**
      * Get the paired .server.ts file for a .page.ts file, or vice versa.
      */
     getPairedFile(filePath: string): string | undefined;
     /**
      * Find routes whose URL path matches a given string (for go-to-definition).
-     * Matches both exact paths and parameterized patterns.
+     * Scoped to the project containing the given document.
      */
-    findByUrlString(urlString: string): RouteInfo[];
+    findByUrlString(urlString: string, documentPath?: string): RouteInfo[];
 }

package/out/routeScanner.js

@@ -89,43 +89,106 @@ function collectFiles(dir, test) {
     return results;
 }
 /**
- * Scans the workspace for Analog page files and builds a route map.
+ * Find all projects with `src/app/pages` directories.
+ * Returns an array of { projectRoot, pagesDir } pairs.
+ */
+function findProjects(root) {
+    const results = [];
+    const seen = new Set();
+    function add(projectRoot, pagesDir) {
+        const resolved = path.resolve(pagesDir);
+        if (seen.has(resolved))
+            return;
+        seen.add(resolved);
+        results.push({ projectRoot: path.resolve(projectRoot), pagesDir: resolved });
+    }
+    // Direct project: root/src/app/pages
+    const direct = path.join(root, 'src', 'app', 'pages');
+    if (fs.existsSync(direct)) {
+        add(root, direct);
+    }
+    // Monorepo: scan common app directories
+    const monorepoParents = ['apps', 'projects', 'packages'];
+    for (const parent of monorepoParents) {
+        const parentDir = path.join(root, parent);
+        let entries;
+        try {
+            entries = fs.readdirSync(parentDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const projectRoot = path.join(parentDir, entry.name);
+            const candidate = path.join(projectRoot, 'src', 'app', 'pages');
+            if (fs.existsSync(candidate)) {
+                add(projectRoot, candidate);
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Scans the workspace for Analog page files and builds a route map,
+ * grouped by project so monorepo routes are scoped correctly.
  */
 class RouteScanner {
     constructor(workspaceRoot) {
-        this.routes = [];
+        this.projects = [];
         this.workspaceRoot = workspaceRoot;
     }
     /**
-     * Perform initial scan of the pages directory.
+     * Perform initial scan of all pages directories in the workspace.
      */
     scan() {
-        const pagesDir = path.join(this.workspaceRoot, 'src', 'app', 'pages');
-        const pageFiles = collectFiles(pagesDir, (name) => name.endsWith('.page.ts'));
-        this.routes = pageFiles.map((filePath) => {
-            const urlPath = fileToUrlPath(filePath);
-            const serverFilePath = filePath.replace(/\.page\.ts$/, '.server.ts');
-            const hasServer = fs.existsSync(serverFilePath);
-            return {
-                urlPath,
-                filePath,
-                serverFilePath: hasServer ? serverFilePath : undefined,
-                params: extractParams(urlPath),
-                isCatchAll: urlPath.includes('**'),
-            };
+        this.projects = findProjects(this.workspaceRoot).map(({ projectRoot, pagesDir }) => {
+            const pageFiles = collectFiles(pagesDir, (name) => name.endsWith('.page.ts'));
+            const routes = pageFiles.map((filePath) => {
+                const urlPath = fileToUrlPath(filePath);
+                const serverFilePath = filePath.replace(/\.page\.ts$/, '.server.ts');
+                const hasServer = fs.existsSync(serverFilePath);
+                return {
+                    urlPath,
+                    filePath,
+                    serverFilePath: hasServer ? serverFilePath : undefined,
+                    params: extractParams(urlPath),
+                    isCatchAll: urlPath.includes('**'),
+                };
+            });
+            return { projectRoot, routes };
         });
     }
     /**
-     * Get all discovered routes.
+     * Determine which project a document belongs to based on its file path.
      */
-    getRoutes() {
-        return this.routes;
+    getProjectForFile(documentPath) {
+        const resolved = path.resolve(documentPath);
+        // Find the project whose root is an ancestor of the document.
+        // Sort by longest projectRoot first so nested projects match correctly.
+        return this.projects
+            .filter((p) => resolved.startsWith(p.projectRoot + path.sep) || resolved.startsWith(p.projectRoot + '/'))
+            .sort((a, b) => b.projectRoot.length - a.projectRoot.length)[0];
+    }
+    /**
+     * Get routes scoped to the project containing the given document.
+     * Falls back to all routes if no project match is found.
+     */
+    getRoutes(documentPath) {
+        if (documentPath) {
+            const project = this.getProjectForFile(documentPath);
+            if (project)
+                return project.routes;
+        }
+        // Fallback: return all routes
+        return this.projects.flatMap((p) => p.routes);
     }
     /**
-     * Find a route by its URL path.
+     * Find a route by its URL path, scoped to the document's project.
      */
-    findByUrlPath(urlPath) {
-        return this.routes.find((r) => r.urlPath === urlPath);
+    findByUrlPath(urlPath, documentPath) {
+        return this.getRoutes(documentPath).find((r) => r.urlPath === urlPath);
     }
     /**
      * Get the paired .server.ts file for a .page.ts file, or vice versa.
@@ -143,15 +206,16 @@ class RouteScanner {
     }
     /**
      * Find routes whose URL path matches a given string (for go-to-definition).
-     * Matches both exact paths and parameterized patterns.
+     * Scoped to the project containing the given document.
      */
-    findByUrlString(urlString) {
+    findByUrlString(urlString, documentPath) {
         const normalized = urlString.startsWith('/') ? urlString : '/' + urlString;
-        const exact = this.routes.filter((r) => r.urlPath === normalized);
+        const routes = this.getRoutes(documentPath);
+        const exact = routes.filter((r) => r.urlPath === normalized);
         if (exact.length > 0)
             return exact;
         // Try matching parameterized routes: "/products/123" against "/products/:productId"
-        return this.routes.filter((r) => {
+        return routes.filter((r) => {
             if (r.isCatchAll)
                 return false;
             const routeParts = r.urlPath.split('/');

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@analogjs/language-server",
 	"description": "LSP server for AnalogJS Language Service",
-	"version": "0.2.1",
+	"version": "0.2.4",
 	"main": "out/index.js",
 	"license": "MIT",
 	"scripts": {