Open Model Reference / External Data links on click; bump to 1.2.5

Clicking a Model References or External Data hyperlink in the .slx view did
nothing. The click reached the host intact, but handleNavigate only understood
the Usage-column grammar (name@source); these links carry a bare filename with
no @source, so parseNavTarget returned null and the handler bailed.

Add parseFileTarget for the bare-filename grammar and have handleNavigate try
it first: resolve the file by basename in the workspace and open it (no row to
select). Usage links are unchanged. Covered by navTarget unit tests and a new
handleNavigate integration suite.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ww-mw

package-lock.json

@@ -2,7 +2,7 @@
   "name": "data-explorer-vscode",
   "displayName": "Simulink Data Explorer",
   "description": "Explore Simulink models, data dictionaries, MAT-files, and projects as interactive tables and relationship trees.",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "publisher": "mathworks",
   "icon": "media/icon.png",
   "private": true,

package.json

@@ -22,3 +22,14 @@ export function parseNavTarget(target: string): { name: string; source: string }
   if (!name || !source) return null;
   return { name, source };
 }
+
+// Model Reference / External Data links use a different, simpler grammar than
+// Usage links: their target is a bare filename (e.g. "plant.slx", "signals.mat",
+// "common.sldd") that just means "open this file" — there is no row inside it to
+// select. These carry NO '@source' suffix, so parseNavTarget rejects them.
+// Return the basename to open, or null when the target is a Usage-link (has an
+// '@') that parseNavTarget should handle instead.
+export function parseFileTarget(target: string): string | null {
+  if (!target || target.includes('@')) return null;
+  return target;
+}

src/host/navTarget.ts

@@ -14,9 +14,9 @@
 // component (block->param links carry only the dictionary name); the latter is
 // resolved against the workspace.
 import * as vscode from 'vscode';
-import { parseNavTarget } from './navTarget.js';
+import { parseNavTarget, parseFileTarget } from './navTarget.js';
 
-export { parseNavTarget };
+export { parseNavTarget, parseFileTarget };
 
 // Pending selection per target uri, consumed by that editor's next paint. This
 // covers the just-opened case: the click fires requestSelect BEFORE the new
@@ -54,9 +54,19 @@ async function resolveSource(source: string): Promise<vscode.Uri | undefined> {
   return matches[0];
 }
 
-// Handle a Usage-cell link click: open the target file (via `open`, the host's
-// content-aware editor router) and request selection of the referenced row.
+// Handle a link click. Two grammars land here:
+//  - Usage-cell links carry `name@source`: open the source file (via `open`, the
+//    host's content-aware editor router) and select the referenced row there.
+//  - Model Reference / External Data links carry a bare filename: just open that
+//    file, resolved by basename against the workspace. There is no row to select.
 export async function handleNavigate(target: string, open: (uri: vscode.Uri) => Promise<void>): Promise<void> {
+  const fileTarget = parseFileTarget(target);
+  if (fileTarget) {
+    const uri = await resolveSource(fileTarget);
+    if (!uri) return;
+    await open(uri);
+    return;
+  }
   const parsed = parseNavTarget(target);
   if (!parsed) return;
   const uri = await resolveSource(parsed.source);

src/host/navigate.ts

@@ -0,0 +1,68 @@
+// Copyright 2026 The MathWorks, Inc.
+// Integration tests for handleNavigate — the host-side link-click handler shared
+// by the binary and text editors (wired in extension.ts). Run inside a real VS
+// Code so vscode.workspace.findFiles resolves against the fixture workspace,
+// which the vitest suite cannot do (navigate.ts imports `vscode`). This covers
+// the Model Reference / External Data links, whose target is a BARE filename
+// (e.g. "data.sldd") with no "@source" suffix: the handler must look the file up
+// by basename and open it. The pure target grammar is unit-tested in
+// test/navTarget.test.ts; here we prove the end-to-end resolve-and-open.
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import { handleNavigate } from '../../src/host/navigate';
+
+function wsUri(name: string): vscode.Uri {
+  const ws = vscode.workspace.workspaceFolders?.[0];
+  assert.ok(ws, 'a workspace folder must be open');
+  return vscode.Uri.joinPath(ws.uri, name);
+}
+
+suite('handleNavigate — Model Reference / External Data links', () => {
+  test('a bare filename target resolves in the workspace and opens that file', async () => {
+    const opened: vscode.Uri[] = [];
+    // "data.sldd" is a fixture file; the link target for External Data / Model
+    // Reference rows is exactly this bare basename (no "@source").
+    await handleNavigate('data.sldd', async (uri) => {
+      opened.push(uri);
+    });
+    assert.strictEqual(opened.length, 1, 'the target file is opened exactly once');
+    assert.strictEqual(
+      opened[0].toString(),
+      wsUri('data.sldd').toString(),
+      'the resolved Uri points at the workspace file',
+    );
+  });
+
+  test('a bare .slx model-reference target opens the referenced model', async () => {
+    const opened: vscode.Uri[] = [];
+    await handleNavigate('model.slx', async (uri) => {
+      opened.push(uri);
+    });
+    assert.strictEqual(opened.length, 1, 'the referenced model is opened');
+    assert.strictEqual(opened[0].toString(), wsUri('model.slx').toString());
+  });
+
+  test('a bare filename with no matching workspace file opens nothing', async () => {
+    let called = false;
+    await handleNavigate('does-not-exist.slx', async () => {
+      called = true;
+    });
+    assert.strictEqual(called, false, 'no file is opened when nothing resolves');
+  });
+
+  test('a Usage-link target (name@source) is not treated as a bare file', async () => {
+    // "Kp@data.sldd" carries an '@', so the file-target fast path must decline it
+    // and the Usage-link path handles it: it resolves the SOURCE (data.sldd) and
+    // opens that, not a file literally named "Kp@data.sldd".
+    const opened: vscode.Uri[] = [];
+    await handleNavigate('Kp@data.sldd', async (uri) => {
+      opened.push(uri);
+    });
+    assert.strictEqual(opened.length, 1, 'the source file is opened');
+    assert.strictEqual(
+      opened[0].toString(),
+      wsUri('data.sldd').toString(),
+      'the Usage-link resolves its @source, not the whole target string',
+    );
+  });
+});

test-integration/suite/navigate.test.ts

@@ -1,6 +1,6 @@
 // Copyright 2026 The MathWorks, Inc.
 import { describe, it, expect } from 'vitest';
-import { parseNavTarget } from '../src/host/navTarget.js';
+import { parseNavTarget, parseFileTarget } from '../src/host/navTarget.js';
 
 describe('parseNavTarget — Usage-link target grammar', () => {
   it('parses a bare <name>@<basename> (block -> dictionary variable)', () => {
@@ -38,3 +38,22 @@ describe('parseNavTarget — Usage-link target grammar', () => {
     expect(parseNavTarget('blocks:@x')).toBeNull();
   });
 });
+
+describe('parseFileTarget — Model Reference / External Data bare-file links', () => {
+  it('accepts a bare model-reference basename (no @, no prefix)', () => {
+    // ModelReferenceNode / DataSourceNode set linkTarget to the bare filename.
+    expect(parseFileTarget('plant.slx')).toBe('plant.slx');
+    expect(parseFileTarget('signals.mat')).toBe('signals.mat');
+    expect(parseFileTarget('common.sldd')).toBe('common.sldd');
+  });
+
+  it('returns null for a Usage-link target (has @source) so it does not hijack it', () => {
+    expect(parseFileTarget('Kp@controller.sldd')).toBeNull();
+    expect(parseFileTarget('blocks:Gain1@file:///w/plant.slx')).toBeNull();
+    expect(parseFileTarget('workspace:Ts@model.slx')).toBeNull();
+  });
+
+  it('returns null for empty input', () => {
+    expect(parseFileTarget('')).toBeNull();
+  });
+});