Fixed linting

Author: luca-vogels

package.json

@@ -9,6 +9,7 @@
     ".": "./lib/index.js",
     "./ExpireMap": "./lib/ExpireMap.js",
     "./HashMap": "./lib/HashMap.js",
+    "./ObjectDoubleLinkedList": "./lib/ObjectDoubleLinkedList.js",
     "./ObjectLinkedList": "./lib/ObjectLinkedList.js",
     "./SortedMap": "./lib/SortedMap.js"
   },

src/DynamicBVH.ts

@@ -1,3 +1,3 @@
 // TODO
 
-//export class DynamicBVH {}
+// export class DynamicBVH {}

src/ExpireMap.ts

@@ -32,7 +32,8 @@ export class ExpireMap<K, V> {
 
     // if duplicate keys returns the index of the first one
     private _findIndexFirst(timestamp: number): number {
-        let low = 0, high = this._expireTimes.length;
+        let low = 0;
+        let high = this._expireTimes.length;
         while(low < high){
             const mid = Math.floor((low + high) / 2);
             const cmp = timestamp - (this._expireTimes[mid] as number);
@@ -47,7 +48,8 @@ export class ExpireMap<K, V> {
 
     // if duplicate keys returns the index of the last one
     private _findIndexLast(timestamp: number): number {
-        let low = 0, high = this._expireTimes.length;
+        let low = 0;
+        let high = this._expireTimes.length;
         while(low < high){
             const mid = Math.floor((low + high) / 2);
             const cmp = timestamp - (this._expireTimes[mid] as number);

src/ObjectDoubleLinkedList.ts

@@ -747,15 +747,15 @@ export class ObjectDoubleLinkedList<T extends LinkedListComparator<T>> {
 
         // special case for head
         if(index === 0){
-            const value = this._head.value;
+            const oldHeadValue = this._head.value;
             this._head = this._head.next;
             if(this._head){
                 this._head.prev = null;
             } else {
                 this._tail = null;
             }
             this._size--;
-            return value;
+            return oldHeadValue;
         }
 
         // iterate currNode.next to index
@@ -765,15 +765,15 @@ export class ObjectDoubleLinkedList<T extends LinkedListComparator<T>> {
         }
 
         // currNode.next should be removed
-        const value = currNode!.next!.value;
+        const oldValue = currNode!.next!.value;
         if(currNode!.next!.next){
             currNode!.next!.next!.prev = currNode;
         } else {
             this._tail = currNode;
         }
         currNode!.next = currNode!.next!.next;
         this._size--;
-        return value;
+        return oldValue;
     }
 
     /**
@@ -954,7 +954,7 @@ export class ObjectDoubleLinkedList<T extends LinkedListComparator<T>> {
          * @param size Amount of nodes that should remain linked to head.
          * @returns New head of the second part of the split linked list.
          */
-        function split<T>(head: DoubleLinkedListNode<T> | null, size: number): DoubleLinkedListNode<T> | null {
+        function split<U>(head: DoubleLinkedListNode<U> | null, size: number): DoubleLinkedListNode<U> | null {
             let cur = head;
             for(let i = 1; cur && i < size; i++){
                 cur = cur.next;
@@ -974,11 +974,11 @@ export class ObjectDoubleLinkedList<T extends LinkedListComparator<T>> {
          * @param compare Comparison function.
          * @returns Head and tail of the new merged list.
          */
-        function merge<T>(a: DoubleLinkedListNode<T> | null, b: DoubleLinkedListNode<T> | null, compare: (x: T, y: T) => number): { head: DoubleLinkedListNode<T> | null; tail: DoubleLinkedListNode<T> | null } {
+        function merge<U>(a: DoubleLinkedListNode<U> | null, b: DoubleLinkedListNode<U> | null, compare: (x: U, y: U) => number): { head: DoubleLinkedListNode<U> | null; tail: DoubleLinkedListNode<U> | null } {
             // create new merged list
-            let head: DoubleLinkedListNode<T> | null = null;
-            let tail: DoubleLinkedListNode<T> | null = null;
-            const append = (node: DoubleLinkedListNode<T>) => {
+            let head: DoubleLinkedListNode<U> | null = null;
+            let tail: DoubleLinkedListNode<U> | null = null;
+            const append = (node: DoubleLinkedListNode<U>) => {
                 node.prev = tail;
                 node.next = null;
                 if(tail) tail.next = node;
@@ -1131,7 +1131,7 @@ export class ObjectDoubleLinkedList<T extends LinkedListComparator<T>> {
      * @return Array containing all values in the linked list.
      */
     public toArray(): T[] {
-        const arr: Array<T> = new Array<T>(this._size);
+        const arr: T[] = new Array<T>(this._size);
         let currNode = this._head;
         for(let i=0; i < this._size; i++){
             arr[i] = currNode!.value;

src/ObjectLinkedList.ts

@@ -565,13 +565,13 @@ export class ObjectLinkedList<T extends LinkedListComparator<T>> {
 
         // special case for head
         if(this._head.value.equals(lookup)){
-            const value = this._head.value;
+            const oldValue = this._head.value;
             this._head = this._head.next;
             if(!this._head){
                 this._tail = null;
             }
             this._size--;
-            return value;
+            return oldValue;
         }
 
         // iterate currNode.next to index
@@ -646,12 +646,12 @@ export class ObjectLinkedList<T extends LinkedListComparator<T>> {
 
         // special case for head
         if(index === 0){
-            const value = this._head.value;
+            const oldHeadValue = this._head.value;
             this._head = this._head.next;
             if(!this._head){
                 this._tail = null;
             }
-            return value;
+            return oldHeadValue;
         }
 
         // iterate currNode.next to index
@@ -661,13 +661,13 @@ export class ObjectLinkedList<T extends LinkedListComparator<T>> {
         }
 
         // currNode.next should be removed
-        const value = currNode!.next!.value;
+        const oldValue = currNode!.next!.value;
         if(!currNode!.next!.next){
             this._tail = currNode;
         }
         currNode!.next = currNode!.next!.next;
         this._size--;
-        return value;
+        return oldValue;
     }
 
     /**
@@ -845,7 +845,7 @@ export class ObjectLinkedList<T extends LinkedListComparator<T>> {
          * @param size Amount of nodes that should remain linked to head.
          * @returns New head of the second part of the split linked list.
          */
-        function split<T>(head: LinkedListNode<T> | null, size: number): LinkedListNode<T> | null {
+        function split<U>(head: LinkedListNode<U> | null, size: number): LinkedListNode<U> | null {
             let cur = head;
             for(let i = 1; cur && i < size; i++){
                 cur = cur.next;
@@ -864,11 +864,11 @@ export class ObjectLinkedList<T extends LinkedListComparator<T>> {
          * @param compare Comparison function.
          * @returns Head and tail of the new merged list.
          */
-        function merge<T>(a: LinkedListNode<T> | null, b: LinkedListNode<T> | null, compare: (x: T, y: T) => number): { head: LinkedListNode<T> | null; tail: LinkedListNode<T> | null } {
+        function merge<U>(a: LinkedListNode<U> | null, b: LinkedListNode<U> | null, compare: (x: U, y: U) => number): { head: LinkedListNode<U> | null; tail: LinkedListNode<U> | null } {
             // create new merged list
-            let head: LinkedListNode<T> | null = null;
-            let tail: LinkedListNode<T> | null = null;
-            const append = (node: LinkedListNode<T>) => {
+            let head: LinkedListNode<U> | null = null;
+            let tail: LinkedListNode<U> | null = null;
+            const append = (node: LinkedListNode<U>) => {
                 node.next = null;
                 if(tail) tail.next = node;
                 else head = node;
@@ -1012,7 +1012,7 @@ export class ObjectLinkedList<T extends LinkedListComparator<T>> {
      * @return Array containing all values in the linked list.
      */
     public toArray(): T[] {
-        const arr: Array<T> = new Array<T>(this._size);
+        const arr: T[] = new Array<T>(this._size);
         let currNode = this._head;
         for(let i=0; i < this._size; i++){
             arr[i] = currNode!.value;

src/SortedMap.ts

@@ -33,7 +33,8 @@ export class SortedMap<K, V> {
     }
 
     private _findIndex(key: K): {index: number, alreadyExists: boolean } {
-        let low = 0, high = this.size;
+        let low = 0;
+        let high = this.size;
         while(low < high){
             const mid = Math.floor((low + high) / 2);
             const cmp = this.compare(key, this.myKeys[mid]);
@@ -215,7 +216,7 @@ export class SortedMap<K, V> {
                     const value = self.myValues[idx] as V;
                     idx++;
                     if(k < key || (inclusive && k === key))
-                        return { value: value, done: false };
+                        return { value, done: false };
                 }
                 return { value: undefined, done: true };
             },
@@ -237,7 +238,7 @@ export class SortedMap<K, V> {
                     const value = self.myValues[idx] as V;
                     idx++;
                     if(k > key || (inclusive && k === key))
-                        return { value: value, done: false };
+                        return { value, done: false };
                 }
                 return { value: undefined, done: true };
             },

src/__tests__/ExpireMap.test.ts

@@ -269,9 +269,7 @@ describe('Testing ExpireMap', () => {
 
     await sleep(25);
 
-    console.log(map.toDebugString()); // TODO REMOVE
     map.get("a"); // should reset lifespan of elements
-    console.log(map.toDebugString()); // TODO REMOVE
     map.get("c"); // should reset lifespan of elements
     expect(map.getRemainingLifespan("a")).toBeLessThanOrEqual(50);
     expect(map.getRemainingLifespan("a")).toBeGreaterThan(25);

src/__tests__/ObjectDoubleLinkedList.test.ts

@@ -997,7 +997,6 @@ describe('Testing LinkedList', () => {
     ]);
 
     const resultA = listA.splice(0, 2, new TestEntry(1));
-    console.log(resultA, listA.toDebugString()); // TODO REMOVE
     expect(listA.length).toBe(1);
     expect(listA.at(0)?.value).toBe(1);
     expect(listA.at(1)).toBeUndefined();

tslint.json

@@ -1,3 +1,8 @@
 {
-    "extends": ["tslint:recommended", "tslint-config-prettier"]
+    "extends": ["tslint:recommended", "tslint-config-prettier"],
+    "rules": {
+        "max-classes-per-file": false,
+        "no-bitwise": false,
+        "prefer-for-of": false
+    }
 }