Release v1.1.2

Fix column resize triggering a sort: the trailing click the browser
fires on the <th> after a resize mouseup no longer toggles the column
sort. onUp sets a suppress-next-click flag consumed by the header click
handler, with a setTimeout(0) safety-net so an orphaned flag can't eat a
later genuine sort click.

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 Extension for Visual Studio Code",
   "description": "Explore Simulink models, data dictionaries, MAT-files, and projects as interactive tables and relationship trees.",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "publisher": "mathworks",
   "private": true,
   "license": "BSD-3-Clause",

package.json

@@ -580,6 +580,11 @@ export class DexTreeTable extends LitElement {
   private _resizeStartWidth = 0;
   private _resizeNextCol: string | null = null;
   private _resizeNextStartWidth = 0;
+  // A resize ends on mouseup, but the browser then fires a `click` on the <th>,
+  // which would trigger sorting. `_resizingCol` is already cleared by then, so
+  // this flag carries the "just resized" signal to the click handler to swallow
+  // that one click.
+  private _suppressNextHeaderClick = false;
 
   private _dragColId: string | null = null;
   private _dragOverColId: string | null = null;
@@ -760,6 +765,15 @@ export class DexTreeTable extends LitElement {
       document.removeEventListener('mouseup', onUp);
       this._resizingCol = null;
       this._resizeNextCol = null;
+      // Swallow the click the browser fires on the <th> right after this
+      // mouseup, so ending a resize doesn't also toggle the column sort. The
+      // trailing click dispatches synchronously before this timeout, so the
+      // timeout only clears the flag if no click follows (e.g. mouseup landed
+      // outside the header) — preventing a stuck flag from eating a later sort.
+      this._suppressNextHeaderClick = true;
+      setTimeout(() => {
+        this._suppressNextHeaderClick = false;
+      }, 0);
     };
 
     document.addEventListener('mousemove', onMove);
@@ -944,6 +958,12 @@ export class DexTreeTable extends LitElement {
 
   private _onHeaderClick(col: string, e: MouseEvent): void {
     if (this._resizingCol) return;
+    // A resize just ended: this is the trailing click from that drag, not an
+    // intent to sort. Consume the flag and bail.
+    if (this._suppressNextHeaderClick) {
+      this._suppressNextHeaderClick = false;
+      return;
+    }
 
     if (e.shiftKey) {
       const existing = this._sortState.findIndex((s) => s.column === col);

src/dex/components/dex-tree-table.ts

@@ -60,6 +60,26 @@ describe('dex-tree-table sorting preserves hierarchy', () => {
     expect(visibleOrder(table)).toEqual(['S', 'S/z', 'S/a']);
   });
 
+  it('does not sort on the trailing click that follows a column resize', () => {
+    // Ending a resize (mouseup) is followed by a click on the <th>. That click
+    // must not toggle the sort. The resize's onUp sets _suppressNextHeaderClick;
+    // _onHeaderClick must consume it and leave the sort state untouched.
+    const table = new DexTreeTable();
+    table.rows = [makeRow('S', null, 'Section')];
+    expect((table as any)._sortState).toEqual([]);
+
+    (table as any)._suppressNextHeaderClick = true;
+    (table as any)._onHeaderClick('Name', { shiftKey: false } as MouseEvent);
+
+    // No sort applied, and the flag is consumed (one click only).
+    expect((table as any)._sortState).toEqual([]);
+    expect((table as any)._suppressNextHeaderClick).toBe(false);
+
+    // The NEXT click (a genuine one) sorts as normal.
+    (table as any)._onHeaderClick('Name', { shiftKey: false } as MouseEvent);
+    expect((table as any)._sortState).toEqual([{ column: 'Name', direction: 'asc' }]);
+  });
+
   it('sorts nested grandchildren within their own subtree only', () => {
     const rows: TreeTableRow[] = [
       makeRow('B', null, 'Beta'),