🔨 Add move & remove to CallsModel

Signed-off-by: Babak Khalkhali Shandiz <[email protected]>

Author: babakks

src/models.ts

@@ -6,6 +6,16 @@
 import * as vscode from 'vscode';
 import { HistoryItem, WordAnchor } from './history';
 
+function del<T>(array: T[], e: T): void {
+    const idx = array.indexOf(e);
+    if (idx >= 0) {
+        array.splice(idx, 1);
+    }
+}
+
+function tail<T>(array: T[]): T | undefined {
+    return array[array.length - 1];
+}
 
 export function getRequestRange(doc: vscode.TextDocument, pos: vscode.Position): vscode.Range | undefined {
     let range = doc.getWordRangeAtPosition(pos);
@@ -219,13 +229,13 @@ export class ReferencesModel {
     async remove(item: FileItem | ReferenceItem): Promise<void> {
 
         if (item instanceof FileItem) {
-            ReferencesModel._del(await this.items, item);
+            del(await this.items, item);
             this._onDidChange.fire(this);
 
         } else if (item instanceof ReferenceItem) {
-            ReferencesModel._del(item.parent.results, item);
+            del(item.parent.results, item);
             if (item.parent.results.length === 0) {
-                ReferencesModel._del(await this.items, item.parent);
+                del(await this.items, item.parent);
                 this._onDidChange.fire(this);
             } else {
                 this._onDidChange.fire(item.parent);
@@ -246,14 +256,14 @@ export class ReferencesModel {
             if (fwd) {
                 return _move(item).results[0];
             } else {
-                return ReferencesModel._tail(_move(item).results);
+                return tail(_move(item).results);
             }
         }
 
         if (item instanceof ReferenceItem) {
             const idx = item.parent.results.indexOf(item) + delta;
             if (idx < 0) {
-                return ReferencesModel._tail(_move(item.parent).results);
+                return tail(_move(item.parent).results);
             } else if (idx >= item.parent.results.length) {
                 return _move(item.parent).results[0];
             } else {
@@ -294,17 +304,6 @@ export class ReferencesModel {
         }
         return pos;
     }
-
-    private static _del<T>(array: T[], e: T): void {
-        const idx = array.indexOf(e);
-        if (idx >= 0) {
-            array.splice(idx, 1);
-        }
-    }
-
-    private static _tail<T>(array: T[]): T | undefined {
-        return array[array.length - 1];
-    }
 }
 
 
@@ -346,6 +345,8 @@ export class RichCallsDirection {
 }
 
 export class CallItem {
+    children: CallItem[] | undefined = undefined
+    
     constructor(
         readonly item: vscode.CallHierarchyItem,
         readonly parent: CallItem | undefined,
@@ -359,6 +360,9 @@ export class CallsModel {
 
     readonly roots: Promise<CallItem[]>;
 
+    private readonly _onDidChange = new vscode.EventEmitter<CallsModel | CallItem>();
+    readonly onDidChange = this._onDidChange.event;
+
     constructor(readonly uri: vscode.Uri, readonly position: vscode.Position, readonly direction: CallsDirection) {
         this.roots = Promise.resolve(vscode.commands.executeCommand<vscode.CallHierarchyItem[]>('vscode.prepareCallHierarchy', uri, position)).then(items => {
             return items ? items.map(item => new CallItem(item, undefined, undefined)) : [];
@@ -388,6 +392,36 @@ export class CallsModel {
         return first;
     }
 
+    async move(item: CallItem, fwd: boolean): Promise<CallItem | undefined> {
+        const roots = await this.roots;
+        const array = -1 !== roots.indexOf(item) ? roots : item.parent?.children;
+
+        if(!array?.length)
+            return undefined;
+
+        const ix0 = array.indexOf(item)
+        if (1 == array.length && 0 == ix0)
+            return undefined; // No siblings to move to.
+
+        const delta = fwd ? +1 : -1;
+        const ix = (ix0 + delta + array.length) % array.length;
+        return array[ix];
+    }
+
+    async remove(item: CallItem): Promise<void> {
+        const roots = await this.roots;
+        if (-1 !== roots.indexOf(item)) {
+            del(roots, item);
+            this._onDidChange.fire(this);
+            return;
+        }
+
+        if (!item.parent?.children)
+            return;
+        del(item.parent.children, item);
+        this._onDidChange.fire(this);
+    }
+
     async asHistoryItem(args: any[]) {
 
         const [first] = await this.roots;