Update v1.3.4 to resolve issues

Author: dklilley

package-lock.json

@@ -212,8 +212,8 @@ export default class ExecutionCommandProvider {
         const fileName = path.basename(editor.document.fileName);
         const filePath = editor.document.isUntitled ? fileName : path.basename(editor.document.fileName);
         const text = editor.document.getText();
-        const lineRange = sectionData.sectionsTree.find(editor.selection.active.line);
-        const sectionLineRanges = sectionData.sectionRanges.map((range) => [range.start.line + 1, range.end.line + 1]);
+        const lineRange = sectionData.sectionsTree.find(editor.selection.active.line)?.range;
+        const sectionLineRanges = sectionData.sectionRanges.map((section) => [section.range.start.line + 1, section.range.end.line + 1]);
 
         if (lineRange === undefined) {
             return;
@@ -226,28 +226,47 @@ export default class ExecutionCommandProvider {
             return;
         }
 
-        const args: any[] = [
-            fileName,
-            filePath,
-            text,
-            lineRange.start.line + 1,
-            lineRange.end.line + 1,
-            -1,
-            'vscode',
-            '',
-            false,
-            false
-        ];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let args: any[];
 
         switch (this._mvm.getMatlabRelease()) {
             case undefined:
             case 'R2021b':
             case 'R2022a':
             case 'R2022b':
-            case 'R2023a':
+            case 'R2023a': {
+                const splitLines = text.split(/\r\n|\r|\n/);
+                const startPosition = splitLines.slice(0, lineRange.start.line).join('\n').length + 1;
+                const executionLength = splitLines.slice(lineRange.start.line, lineRange.end.line + 1).join('\n').length + 1;
+
+                args = [
+                    fileName,
+                    filePath,
+                    text,
+                    startPosition,
+                    executionLength,
+                    -1,
+                    'vscode',
+                    '',
+                    false,
+                    false
+                ];
                 break;
+            }
             default:
-                args.push(sectionLineRanges);
+                args = [
+                    fileName,
+                    filePath,
+                    text,
+                    lineRange.start.line + 1,
+                    lineRange.end.line + 1,
+                    -1,
+                    'vscode',
+                    '',
+                    false,
+                    false,
+                    sectionLineRanges
+                ];
                 break;
         }
 

server

@@ -1,18 +1,25 @@
 // Copyright 2024-2025 The MathWorks, Inc.
 import * as vscode from 'vscode';
 
+export interface SectionData {
+    range: vscode.Range
+    isExplicit: boolean
+}
+
 /**
  * A node used in the LineRangeTree.
  * @class TreeNode
  */
 class TreeNode {
-    range: vscode.Range | undefined;
+    range?: vscode.Range;
+    section?: SectionData;
     children: TreeNode[];
     parent: TreeNode | undefined;
-    constructor (range: vscode.Range | undefined) {
-        this.range = range;
+    constructor (section?: SectionData) {
+        this.range = section?.range;
         this.children = [];
         this.parent = undefined;
+        this.section = section;
     }
 
     add (treeNode: TreeNode): void {
@@ -39,14 +46,14 @@ class TreeNode {
 export default class LineRangeTree {
     private _root: TreeNode | undefined;
 
-    constructor (sectonRanges: vscode.Range[]) {
-        this._set(sectonRanges);
+    constructor (sectons: SectionData[]) {
+        this._set(sectons);
     }
 
     /**
      * Creates a tree from the given section ranges array based on the start and end lines.
      */
-    _set (sectonRanges: vscode.Range[]): void {
+    _set (sectonRanges: SectionData[]): void {
         this._root = new TreeNode(undefined);
         const objectLength = sectonRanges.length;
         let currentNode: TreeNode | undefined;
@@ -73,7 +80,7 @@ export default class LineRangeTree {
      * @param line number
      * @returns Section Range
      */
-    find (line: number): vscode.Range | undefined {
+    find (line: number): SectionData | undefined {
         let currentNode: TreeNode | undefined;
 
         currentNode = this._root;
@@ -83,7 +90,7 @@ export default class LineRangeTree {
             currentNode = this._searchByLine(line, currentNode);
             lastNode = currentNode ?? lastNode;
         }
-        return (lastNode != null) ? lastNode.range : undefined;
+        return (lastNode != null) ? lastNode.section : undefined;
     }
 
     private _searchByLine (line: number, parentNode: TreeNode): TreeNode | undefined {

src/commandwindow/ExecutionCommandProvider.ts

@@ -2,13 +2,15 @@
 
 import * as vscode from 'vscode';
 import Notification from '../Notifications'
-import LineRangeTree from './LineRangeTree';
+import LineRangeTree, { SectionData } from './LineRangeTree';
 import { Notifier, Disposer } from '../commandwindow/Utilities';
 import { EventEmitter } from 'events';
 
+export { SectionData };
+
 export interface SectionsData {
     uri: string
-    sectionRanges: vscode.Range[]
+    sectionRanges: SectionData[]
     sectionsTree?: LineRangeTree
     isDirty?: boolean
 }
@@ -50,7 +52,7 @@ export class SectionModel extends Disposer {
             return
         }
 
-        sectionsData.sectionRanges.sort((a: vscode.Range, b: vscode.Range) => a.start.line - b.start.line);
+        sectionsData.sectionRanges.sort((a: SectionData, b: SectionData) => a.range.start.line - b.range.start.line);
         sectionsData.sectionsTree = new LineRangeTree(sectionsData.sectionRanges);
         sectionsData.isDirty = false;
 

src/model/LineRangeTree.ts

@@ -2,7 +2,7 @@
 import * as vscode from 'vscode';
 
 import { blueBorderTopDecoration, blueBorderBottomDecoration, greyBorderTopDecoration, greyBorderBottomDecoration, fontWeightBoldDecoration } from './Decorations';
-import { SectionModel, SectionsData } from '../model/SectionModel'
+import { SectionModel, SectionsData, SectionData } from '../model/SectionModel'
 import { Disposer } from '../commandwindow/Utilities';
 import { StartAndEndLines, TopAndBottomRanges, StylingRanges } from './StylingInterfaces';
 let previousFocusedEditor: vscode.TextEditor | undefined;
@@ -105,7 +105,8 @@ export class SectionStylingService extends Disposer {
      */
     private _highlightSections (editor: vscode.TextEditor, sections: SectionsData, activeCursorPosition: vscode.Position | null): void {
         const startAndEndLines = this._sectionsToStartAndEndLines(sections.sectionRanges);
-        const allStartLinesRange = this._generateRanges(startAndEndLines.startLines);
+        const explicitStartAndEndLines = this._sectionsToStartAndEndLines(sections.sectionRanges.filter((section) => section.isExplicit));
+        const explicitSectionRanges = this._generateRanges(explicitStartAndEndLines.startLines);
         const lastLineinSection = startAndEndLines.endLines.sort((a, b) => a - b)[startAndEndLines.endLines.length - 1];
 
         let stylingRanges: StylingRanges;
@@ -114,9 +115,9 @@ export class SectionStylingService extends Disposer {
             if (cursorPositionLine > lastLineinSection) {
                 cursorPositionLine = lastLineinSection
             }
-            const focusedSectionRange: vscode.Range | undefined = this._findFocusedSectionRange(sections, cursorPositionLine);
-            if (focusedSectionRange !== undefined) {
-                stylingRanges = this._getBlueAndGreyRanges(startAndEndLines, focusedSectionRange);
+            const focusedSection = this._findFocusedSection(sections, cursorPositionLine);
+            if (focusedSection !== undefined) {
+                stylingRanges = this._getBlueAndGreyRanges(startAndEndLines, focusedSection);
             } else {
                 stylingRanges = { blue: { top: [], bottom: [] }, grey: this._getGreyRanges(startAndEndLines) };
             }
@@ -125,12 +126,12 @@ export class SectionStylingService extends Disposer {
         }
         this._filterFirstAndLastSection(stylingRanges, lastLineinSection, editor.document);
 
-        this._setDecorations(editor, stylingRanges, allStartLinesRange);
+        this._setDecorations(editor, stylingRanges, explicitSectionRanges);
     }
 
-    private _getBlueAndGreyRanges (startAndEndLines: StartAndEndLines, focusedSectionRange: vscode.Range): StylingRanges {
-        const focusedStartLine = focusedSectionRange.start.line;
-        const focusedEndLine = focusedSectionRange.end.line;
+    private _getBlueAndGreyRanges (startAndEndLines: StartAndEndLines, focusedSectionRange: SectionData): StylingRanges {
+        const focusedStartLine = focusedSectionRange.range.start.line;
+        const focusedEndLine = focusedSectionRange.range.end.line;
         const { startLines, endLines } = startAndEndLines;
 
         const startLinesWithoutFocusLine = startLines.filter((startLine) => {
@@ -181,32 +182,32 @@ export class SectionStylingService extends Disposer {
         return { top: this._generateRanges(startLines), bottom: this._generateRanges(endLinesFiltered) };
     }
 
-    private _setDecorations (editor: vscode.TextEditor, stylingRange: StylingRanges, allStartLinesRange: vscode.Range[]): void {
+    private _setDecorations (editor: vscode.TextEditor, stylingRange: StylingRanges, explicitSectionRanges: vscode.Range[]): void {
         editor.setDecorations(blueBorderTopDecoration, stylingRange.blue.top);
         editor.setDecorations(blueBorderBottomDecoration, stylingRange.blue.bottom);
         editor.setDecorations(greyBorderTopDecoration, stylingRange.grey.top);
         editor.setDecorations(greyBorderBottomDecoration, stylingRange.grey.bottom);
-        editor.setDecorations(fontWeightBoldDecoration, allStartLinesRange);
+        editor.setDecorations(fontWeightBoldDecoration, explicitSectionRanges);
     }
 
     private _generateRanges (lines: number[]): vscode.Range[] {
         return lines.map((line: number) => new vscode.Range(line, 0, line, Infinity));
     }
 
-    private _findFocusedSectionRange (sections: SectionsData, lineNumber: number): vscode.Range | undefined {
-        let activeSection: vscode.Range | undefined;
+    private _findFocusedSection (sections: SectionsData, lineNumber: number): SectionData | undefined {
+        let activeSection: SectionData | undefined;
         if (lineNumber !== undefined && sections.sectionsTree !== undefined) {
             activeSection = sections.sectionsTree.find(lineNumber);
         }
         return activeSection;
     }
 
-    private _sectionsToStartAndEndLines (sectionRanges: vscode.Range[]): StartAndEndLines {
+    private _sectionsToStartAndEndLines (sectionRanges: SectionData[]): StartAndEndLines {
         const startLines = new Set<number>();
         const endLines = new Set<number>();
-        sectionRanges.forEach((sectionRange: vscode.Range) => {
-            const startingIndex = sectionRange.start.line;
-            const endingIndex = sectionRange.end.line;
+        sectionRanges.forEach((sectionRange: SectionData) => {
+            const startingIndex = sectionRange.range.start.line;
+            const endingIndex = sectionRange.range.end.line;
             startLines.add(startingIndex);
             endLines.add(endingIndex);
         });

src/model/SectionModel.ts

@@ -4,4 +4,4 @@
 
 %% Section 2
 a
-disp('This is second section')
+disp('This is second section')

src/styling/SectionStylingService.ts

@@ -1,5 +1,6 @@
-// Copyright 2024 The MathWorks, Inc.
+// Copyright 2024-2025 The MathWorks, Inc.
 module.exports = {
     timeout: 600000,
-    ui: 'tdd'
+    ui: 'tdd',
+    retries: 1,
 }