data-structure-typed 1.54.3 → 2.0.1

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -842,3 +842,138 @@ describe('LinkedHashMap', () => {
     });
   });
 });
+
+describe('classic uses', () => {
+  it('@example should maintain insertion order', () => {
+    const linkedHashMap = new LinkedHashMap<number, string>();
+    linkedHashMap.set(1, 'A');
+    linkedHashMap.set(2, 'B');
+    linkedHashMap.set(3, 'C');
+
+    const result = Array.from(linkedHashMap);
+    expect(result).toEqual([
+      [1, 'A'],
+      [2, 'B'],
+      [3, 'C']
+    ]);
+  });
+
+  it('should allow reverse iteration', () => {
+    const linkedHashMap = new LinkedHashMap<number, string>();
+    linkedHashMap.set(1, 'A');
+    linkedHashMap.set(2, 'B');
+    linkedHashMap.set(3, 'C');
+
+    const result = Array.from(linkedHashMap.reverseBegin());
+    expect(result).toEqual([
+      [3, 'C'],
+      [2, 'B'],
+      [1, 'A']
+    ]);
+  });
+
+  it('should allow fast deletion at an index', () => {
+    const linkedHashMap = new LinkedHashMap<number, string>();
+    linkedHashMap.set(1, 'A');
+    linkedHashMap.set(2, 'B');
+    linkedHashMap.set(3, 'C');
+
+    linkedHashMap.deleteAt(1);
+
+    const result = Array.from(linkedHashMap);
+    expect(result).toEqual([
+      [1, 'A'],
+      [3, 'C']
+    ]);
+  });
+
+  it('should filter entries correctly', () => {
+    const linkedHashMap = new LinkedHashMap<number, string>();
+    linkedHashMap.set(1, 'A');
+    linkedHashMap.set(2, 'B');
+    linkedHashMap.set(3, 'C');
+
+    const filteredMap = linkedHashMap.filter((key, value) => value !== 'B');
+
+    const result = Array.from(filteredMap);
+    expect(result).toEqual([
+      [1, 'A'],
+      [3, 'C']
+    ]);
+  });
+
+  it('should map entries to a new LinkedHashMap', () => {
+    const linkedHashMap = new LinkedHashMap<number, string>();
+    linkedHashMap.set(1, 'A');
+    linkedHashMap.set(2, 'B');
+
+    const mappedMap = linkedHashMap.map((key, value) => [value, key]);
+
+    const result = Array.from(mappedMap);
+    expect(result).toEqual([
+      ['A', 1],
+      ['B', 2]
+    ]);
+  });
+});
+
+describe('classic uses', () => {
+  it('@example fast lookup of values by key', () => {
+    const hashMap = new HashMap<number, string>();
+    hashMap.set(1, 'A');
+    hashMap.set(2, 'B');
+    hashMap.set(3, 'C');
+
+    expect(hashMap.get(1)).toBe('A');
+    expect(hashMap.get(2)).toBe('B');
+    expect(hashMap.get(3)).toBe('C');
+    expect(hashMap.get(99)).toBeUndefined(); // Key not present
+  });
+
+  it('@example remove duplicates when adding multiple entries', () => {
+    const hashMap = new HashMap<number, string>();
+    hashMap.set(1, 'A');
+    hashMap.set(2, 'B');
+    hashMap.set(1, 'C'); // Update value for key 1
+
+    expect(hashMap.size).toBe(2);
+    expect(hashMap.get(1)).toBe('C');
+    expect(hashMap.get(2)).toBe('B');
+  });
+
+  it('@example count occurrences of keys', () => {
+    const data = [1, 2, 1, 3, 2, 1];
+
+    const countMap = new HashMap<number, number>();
+    for (const key of data) {
+      countMap.set(key, (countMap.get(key) || 0) + 1);
+    }
+
+    expect(countMap.get(1)).toBe(3);
+    expect(countMap.get(2)).toBe(2);
+    expect(countMap.get(3)).toBe(1);
+  });
+
+  it('should group entries by a key-derived property', () => {
+    const entries = [
+      { id: 1, group: 'A' },
+      { id: 2, group: 'B' },
+      { id: 3, group: 'A' },
+      { id: 4, group: 'B' }
+    ];
+
+    const groupedMap = new HashMap<string, number[]>();
+
+    for (const entry of entries) {
+      const group = entry.group;
+      const id = entry.id;
+      if (!groupedMap.has(group)) {
+        groupedMap.set(group, []);
+      }
+      groupedMap.get(group)?.push(id);
+    }
+
+    expect(groupedMap.get('A')).toEqual([1, 3]);
+    expect(groupedMap.get('B')).toEqual([2, 4]);
+  });
+});

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -32,14 +32,14 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should deleteAt', () => {
-    expect(list.deleteAt(1)).toBe(true);
-    expect(list.deleteAt(-1)).toBe(false);
-    expect(list.deleteAt(list.size)).toBe(false);
-    expect(list.size).toBe(4);
-    expect(list.deleteAt(4)).toBe(false);
+    expect(list.deleteAt(1)).toBe(2);
+    expect(list.deleteAt(-1)).toBe(undefined);
+    expect(list.deleteAt(list.length)).toBe(undefined);
+    expect(list.length).toBe(4);
+    expect(list.deleteAt(4)).toBe(undefined);
     expect([...list]).toEqual([1, 3, 4, 5]);
     expect(list.isEmpty()).toBe(false);
-    expect(list.deleteAt(3)).toBe(true);
+    expect(list.deleteAt(3)).toBe(5);
     expect([...list]).toEqual([1, 3, 4]);
   });
 
@@ -103,7 +103,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -119,17 +119,36 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.size).toBe(3);
+    expect(list.length).toBe(3);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
   });
 
+  it('push with maxLen', () => {
+    const list = new DoublyLinkedList<number>([], { maxLen: 10 });
+    for (let i = 0; i < 1000; i++) {
+      list.push(i);
+    }
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.first).toBe(990);
+
+    list.clear();
+    for (let i = 0; i < 1000; i++) {
+      list.unshift(i);
+    }
+
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.last).toBe(990);
+  });
+
   it('should pop elements from the end of the list', () => {
     list.push(1);
     list.push(2);
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
     list.pop();
@@ -145,19 +164,19 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Inserting at the beginning
     list.addAt(0, 0);
-    expect(list.size).toBe(4);
+    expect(list.length).toBe(4);
     expect(list.at(0)).toBe(0);
     expect(list.at(1)).toBe(1);
 
     // Inserting in the middle
     list.addAt(2, 1.5);
-    expect(list.size).toBe(5);
+    expect(list.length).toBe(5);
     expect(list.at(2)).toBe(1.5);
     expect(list.at(3)).toBe(2);
 
     // Inserting at the end
     list.addAt(5, 4);
-    expect(list.size).toBe(6);
+    expect(list.length).toBe(6);
     expect(list.at(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
     expect(list.at(-1)).toBe(undefined);
@@ -171,18 +190,18 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Deleting from the beginning
     const deletedValue = list.deleteAt(0);
-    expect(deletedValue).toBe(true);
-    expect(list.size).toBe(2);
+    expect(deletedValue).toBe(1);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -193,16 +212,16 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     list.delete(2);
-    expect(list.size).toBe(2);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
 
     list.delete(1);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     list.delete(3);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -307,7 +326,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.clear();
 
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -447,6 +466,95 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 });
 
+describe('DoublyLinkedList Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new DoublyLinkedList([1, 2]);
+    const list2 = new DoublyLinkedList([3, 4]);
+    const list3 = new DoublyLinkedList([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new DoublyLinkedList([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new DoublyLinkedList(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('iterable methods', () => {
   it('should forEach, some, every, filter, map, reduce of the deque', () => {
     const dl = new DoublyLinkedList<number>();
@@ -578,7 +686,7 @@ describe('classic use', () => {
         const initialNode = this.currentSong;
 
         // Loop through the playlist twice
-        for (let i = 0; i < this.playlist.size * 2; i++) {
+        for (let i = 0; i < this.playlist.length * 2; i++) {
           playedSongs.push(this.currentSong!.value);
           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
         }
@@ -700,7 +808,7 @@ describe('classic use', () => {
         }
 
         // Check capacity
-        if (this.list.size >= this.capacity) {
+        if (this.list.length >= this.capacity) {
           // Delete the least recently used element (the tail of the linked list)
           const removedNode = this.list.tail;
           if (removedNode) {
@@ -745,9 +853,9 @@ describe('classic use', () => {
         this.map.clear();
       }
 
-      // Get the current cache size
-      get size(): number {
-        return this.list.size;
+      // Get the current cache length
+      get length(): number {
+        return this.list.length;
       }
 
       // Check if it is empty
@@ -806,7 +914,7 @@ describe('classic use', () => {
 
     expect(cache.delete('a')).toBe(true);
     expect(cache.get('a')).toBeUndefined();
-    expect(cache.size).toBe(1);
+    expect(cache.length).toBe(1);
 
     // Should support clearing cache
     cache.clear();
@@ -814,7 +922,7 @@ describe('classic use', () => {
     cache.set('b', 2);
     cache.clear();
 
-    expect(cache.size).toBe(0);
+    expect(cache.length).toBe(0);
     expect(cache.isEmpty).toBe(true);
   });
 

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -1,4 +1,4 @@
-import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
+import { SinglyLinkedList, SinglyLinkedListNode, Stack } from '../../../../src';
 
 describe('SinglyLinkedListNode', () => {
   it('should SinglyLinkedList', () => {
@@ -37,6 +37,16 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(2);
       expect(list.toArray()).toEqual([1, 2]);
     });
+
+    it('push with maxLen', () => {
+      const list = new SinglyLinkedList<number>([], { maxLen: 10 });
+      for (let i = 0; i < 1000; i++) {
+        list.push(i);
+      }
+      expect(list.maxLen).toBe(10);
+      expect(list.length).toBe(10);
+      expect(list.first).toBe(990);
+    });
   });
 
   describe('pop', () => {
@@ -187,7 +197,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       list.clear();
       expect(list.toArray()).toEqual([]);
-      expect(list.size).toBe(0);
+      expect(list.length).toBe(0);
       expect(list.isEmpty()).toBe(true);
     });
   });
@@ -277,10 +287,10 @@ describe('SinglyLinkedList Operation Test', () => {
 
   describe('getLength', () => {
     it('should return the correct length of the list', () => {
-      expect(list.size).toBe(0);
+      expect(list.length).toBe(0);
       list.push(1);
       list.push(2);
-      expect(list.size).toBe(2);
+      expect(list.length).toBe(2);
     });
   });
 
@@ -290,14 +300,14 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(2);
       list.push(3);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(true);
+      expect(removed).toBe(2);
       expect(list.toArray()).toEqual([1, 3]);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
       list.push(1);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(false);
+      expect(removed).toBe(undefined);
     });
 
     it('should delete and return the first element', () => {
@@ -308,7 +318,7 @@ describe('SinglyLinkedList Operation Test', () => {
       const removed = list.deleteAt(0);
       expect(list.first).toBe(2);
       expect(list.last).toBe(2);
-      expect(removed).toBe(true);
+      expect(removed).toBe(1);
       expect(list.toArray()).toEqual([2]);
     });
 
@@ -316,7 +326,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(true);
+      expect(removed).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
   });
@@ -448,6 +458,95 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 });
 
+describe('SinglyLinkedList Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new SinglyLinkedList([1, 2]);
+    const list2 = new SinglyLinkedList([3, 4]);
+    const list3 = new SinglyLinkedList([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new SinglyLinkedList([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new SinglyLinkedList(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('SinglyLinkedList', () => {
   let list: SinglyLinkedList<number>;
 
@@ -458,7 +557,7 @@ describe('SinglyLinkedList', () => {
   it('should initialize an empty list', () => {
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
   });
 
   it('should push elements to the end of the list', () => {
@@ -466,7 +565,7 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(2);
-    expect(list.size).toBe(2);
+    expect(list.length).toBe(2);
   });
 
   it('should pop elements from the end of the list', () => {
@@ -476,7 +575,7 @@ describe('SinglyLinkedList', () => {
     expect(popped).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
   });
 
   it('should reverse the list', () => {
@@ -545,7 +644,79 @@ describe('iterable methods', () => {
     expect(sl.some(element => element > 2)).toBe(true);
 
     expect([...sl.filter(element => element > 2)]).toEqual([3]);
-    expect([...sl.map(element => element * 2)]).toEqual([2, 4, 6]);
+    const mappedSl = sl.map(element => element * 2);
+    expect([...mappedSl]).toEqual([2, 4, 6]);
     expect(sl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
 });
+
+describe('classic uses', () => {
+
+  it('@example implementation of a basic text editor', () => {
+
+    class TextEditor {
+      private content: SinglyLinkedList<string>;
+      private cursorIndex: number;
+      private undoStack: Stack<{ operation: string; data?: any }>;
+
+      constructor() {
+        this.content = new SinglyLinkedList<string>();
+        this.cursorIndex = 0; // Cursor starts at the beginning
+        this.undoStack = new Stack<{ operation: string; data?: any }>(); // Stack to keep track of operations for undo
+      }
+
+      insert(char: string) {
+        this.content.addAt(this.cursorIndex, char);
+        this.cursorIndex++;
+        this.undoStack.push({ operation: 'insert', data: { index: this.cursorIndex - 1 } });
+      }
+
+      delete() {
+        if (this.cursorIndex === 0) return; // Nothing to delete
+        const deleted = this.content.deleteAt(this.cursorIndex - 1);
+        this.cursorIndex--;
+        this.undoStack.push({ operation: 'delete', data: { index: this.cursorIndex, char: deleted } });
+      }
+
+      moveCursor(index: number) {
+        this.cursorIndex = Math.max(0, Math.min(index, this.content.length));
+      }
+
+      undo() {
+        if (this.undoStack.size === 0) return; // No operations to undo
+        const lastAction = this.undoStack.pop();
+
+        if (lastAction!.operation === 'insert') {
+          this.content.deleteAt(lastAction!.data.index);
+          this.cursorIndex = lastAction!.data.index;
+        } else if (lastAction!.operation === 'delete') {
+          this.content.addAt(lastAction!.data.index, lastAction!.data.char);
+          this.cursorIndex = lastAction!.data.index + 1;
+        }
+      }
+
+      getText(): string {
+        return [...this.content].join('');
+      }
+    }
+
+    // Example Usage
+    const editor = new TextEditor();
+    editor.insert('H');
+    editor.insert('e');
+    editor.insert('l');
+    editor.insert('l');
+    editor.insert('o');
+    expect(editor.getText()).toBe('Hello'); // Output: "Hello"
+
+    editor.delete();
+    expect(editor.getText()).toBe('Hell'); // Output: "Hell"
+
+    editor.undo();
+    expect(editor.getText()).toBe('Hello'); // Output: "Hello"
+
+    editor.moveCursor(1);
+    editor.insert('a');
+    expect(editor.getText()).toBe('Haello'); // Output: "Haello"
+  });
+});