@futdevpro/fsm-dynamo 1.15.21 → 1.15.22

package/src/_collections/utils/round-list.util.spec.ts

@@ -1,79 +1,79 @@
-
-import { DyFM_RoundList } from './round-list.util';
-
-describe('| DyFM_RoundList', () => {
-
-  describe('| getOutboundedIndex', () => {
-    it('| should throw an error if listLength is 0', () => {
-      expect(() => DyFM_RoundList.getOutboundedIndex(0, 5)).toThrowError('roundListPlusIndex failed. list is empty!');
-    });
-
-    it('| should return correct index for positive outboundIndex within bounds', () => {
-      expect(DyFM_RoundList.getOutboundedIndex(5, 3)).toBe(3);
-    });
-
-    it('| should return correct index for positive outboundIndex out of bounds', () => {
-      expect(DyFM_RoundList.getOutboundedIndex(5, 7)).toBe(2);
-    });
-
-    it('| should return correct index for negative outboundIndex', () => {
-      expect(DyFM_RoundList.getOutboundedIndex(5, -2)).toBe(3);
-    });
-  });
-
-  describe('| getIndexOpposite', () => {
-    it('| should return the opposite index in a circular manner', () => {
-      expect(DyFM_RoundList.getIndexOpposite(8, 7)).toBe(3);
-    });
-
-    it('| should handle even length arrays correctly', () => {
-      expect(DyFM_RoundList.getIndexOpposite(4, 1)).toBe(3);
-    });
-
-    it('| should handle odd length arrays correctly', () => {
-      expect(DyFM_RoundList.getIndexOpposite(5, 2)).toBe(0);
-    });
-  });
-
-  describe('| getListIndex', () => {
-    it('| should return the correct element for a given outboundIndex', () => {
-      const list = ['a', 'b', 'c', 'd'];
-      expect(DyFM_RoundList.getListIndex(list, 5)).toBe('b');
-    });
-
-    it('| should handle negative outboundIndex', () => {
-      const list = ['a', 'b', 'c', 'd'];
-      expect(DyFM_RoundList.getListIndex(list, -1)).toBe('d');
-    });
-  });
-
-  describe('| getListOpposite', () => {
-    it('| should return the opposite element in a circular manner', () => {
-      const list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
-      expect(DyFM_RoundList.getListOpposite(list, 'h')).toBe('d');
-    });
-
-    it('| should handle even length lists correctly', () => {
-      const list = ['a', 'b', 'c', 'd'];
-      expect(DyFM_RoundList.getListOpposite(list, 'b')).toBe('d');
-    });
-
-    it('| should handle odd length lists correctly', () => {
-      const list = ['a', 'b', 'c', 'd', 'e'];
-      expect(DyFM_RoundList.getListOpposite(list, 'c')).toBe('a');
-    });
-  });
-
-  describe('| getLast', () => {
-    it('| should return the last element of the list', () => {
-      const list = ['a', 'b', 'c'];
-      expect(DyFM_RoundList.getLast(list)).toBe('c');
-    });
-
-    it('| should return null for an empty list', () => {
-      const list: string[] = [];
-      expect(DyFM_RoundList.getLast(list)).toBeNull();
-    });
-  });
-
-});
+
+import { DyFM_RoundList } from './round-list.util';
+
+describe('| DyFM_RoundList', () => {
+
+  describe('| getOutboundedIndex', () => {
+    it('| should throw an error if listLength is 0', () => {
+      expect(() => DyFM_RoundList.getOutboundedIndex(0, 5)).toThrowError('roundListPlusIndex failed. list is empty!');
+    });
+
+    it('| should return correct index for positive outboundIndex within bounds', () => {
+      expect(DyFM_RoundList.getOutboundedIndex(5, 3)).toBe(3);
+    });
+
+    it('| should return correct index for positive outboundIndex out of bounds', () => {
+      expect(DyFM_RoundList.getOutboundedIndex(5, 7)).toBe(2);
+    });
+
+    it('| should return correct index for negative outboundIndex', () => {
+      expect(DyFM_RoundList.getOutboundedIndex(5, -2)).toBe(3);
+    });
+  });
+
+  describe('| getIndexOpposite', () => {
+    it('| should return the opposite index in a circular manner', () => {
+      expect(DyFM_RoundList.getIndexOpposite(8, 7)).toBe(3);
+    });
+
+    it('| should handle even length arrays correctly', () => {
+      expect(DyFM_RoundList.getIndexOpposite(4, 1)).toBe(3);
+    });
+
+    it('| should handle odd length arrays correctly', () => {
+      expect(DyFM_RoundList.getIndexOpposite(5, 2)).toBe(0);
+    });
+  });
+
+  describe('| getListIndex', () => {
+    it('| should return the correct element for a given outboundIndex', () => {
+      const list = ['a', 'b', 'c', 'd'];
+      expect(DyFM_RoundList.getListIndex(list, 5)).toBe('b');
+    });
+
+    it('| should handle negative outboundIndex', () => {
+      const list = ['a', 'b', 'c', 'd'];
+      expect(DyFM_RoundList.getListIndex(list, -1)).toBe('d');
+    });
+  });
+
+  describe('| getListOpposite', () => {
+    it('| should return the opposite element in a circular manner', () => {
+      const list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
+      expect(DyFM_RoundList.getListOpposite(list, 'h')).toBe('d');
+    });
+
+    it('| should handle even length lists correctly', () => {
+      const list = ['a', 'b', 'c', 'd'];
+      expect(DyFM_RoundList.getListOpposite(list, 'b')).toBe('d');
+    });
+
+    it('| should handle odd length lists correctly', () => {
+      const list = ['a', 'b', 'c', 'd', 'e'];
+      expect(DyFM_RoundList.getListOpposite(list, 'c')).toBe('a');
+    });
+  });
+
+  describe('| getLast', () => {
+    it('| should return the last element of the list', () => {
+      const list = ['a', 'b', 'c'];
+      expect(DyFM_RoundList.getLast(list)).toBe('c');
+    });
+
+    it('| should return null for an empty list', () => {
+      const list: string[] = [];
+      expect(DyFM_RoundList.getLast(list)).toBeNull();
+    });
+  });
+
+});

package/src/_collections/utils/round-list.util.ts

@@ -1,162 +1,162 @@
-
-
-/**
- * This class is a collection of static methods for round list operations
- * A round list is a list that is circular
- * - after the last element, the first comes next
- */
-export class DyFM_RoundList {  
-  /**
-   * returns the outbound index of the list
-   * @param listLength 
-   * @param outboundIndex 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const listLength = 10;
-   * const outboundIndex = 15;
-   * const result = DyFM_RoundList.getOutboundedIndex(listLength, outboundIndex);
-   * console.log(result); // 5
-   * ```
-   */
-  static getOutboundedIndex(listLength: number, outboundIndex: number): number {
-    if (!listLength) {
-      throw new Error('roundListPlusIndex failed. list is empty!');
-    }
-  
-    if (outboundIndex < 0) {
-      outboundIndex = outboundIndex % listLength;
-      outboundIndex = listLength + outboundIndex;
-    }
-    
-    if (listLength <= outboundIndex) {
-      outboundIndex = outboundIndex % listLength;
-    }
-  
-    return outboundIndex;
-  }
-  
-  /**
-   * returns the index of the opposite element of the list
-   * - as they are circular, the opposite is at the half of the list
-   * - as it is circular, for the second half, the opposite is at the first half
-   * @param length 
-   * @param oppositeOf 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const length = 10;
-   * const oppositeOf = 5;
-   * const result = DyFM_RoundList.getIndexOpposite(length, oppositeOf);
-   * console.log(result); // 0
-   * ```
-   */
-  static getIndexOpposite(length: number, oppositeOf: number): number {
-    const plusIndex = oppositeOf + Math.round(length / 2);
-    const res = this.getOutboundedIndex(length, plusIndex);
-  
-    return res;
-  }
-  
-  /**
-   * returns the element at the outbound index of the list
-   * @param list 
-   * @param outboundIndex 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
-   * const outboundIndex = 15;
-   * const result = DyFM_RoundList.getListIndex(list, outboundIndex);
-   * console.log(result); // 5
-   * ```
-   */
-  static getListIndex<T>(list: T[], outboundIndex: number): T {
-    return list[this.getOutboundedIndex(list.length, outboundIndex)];
-  }
-  
-  /**
-   * returns the element at the opposite index of the list
-   * @param list 
-   * @param oppositeOf 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
-   * const oppositeOf = 5;
-   * const result = DyFM_RoundList.getListOpposite(list, oppositeOf);
-   * console.log(result); // 0
-   * ```
-   */
-  static getListOpposite<T>(list: T[], oppositeOf: T): T {
-    return list[this.getIndexOpposite(list.length, list.indexOf(oppositeOf))];
-  }
-  
-  /**
-   * returns the last element of the list
-   * returns null if the list is empty
-   * 
-   * @example
-   * ```ts
-   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
-   * const result = DyFM_RoundList.getLast(list);
-   * console.log(result); // 10
-   * ```
-   */
-  static getLast<T>(list: T[]): T | null {
-    if (0 < list.length) {
-      return list[list.length - 1];
-    } else {
-      return null;
-    }
-  }
-
-  /** 
-   * returns the opposite index as they circular
-   * so after the last index, the first comes next
-   * an array that has 8 elements, the opposite of 7 is 3
-   * */
-  /* static getRoundListOppositeIndex(
-    arrayLength: number, 
-    index: number, 
-    roundUp: boolean = false
-  ): number {
-    const oppositeIndex = index + (
-      roundUp ? 
-        Math.ceil(arrayLength / 2) : 
-        Math.floor(arrayLength / 2)
-    );
-
-    if (arrayLength <= oppositeIndex) {
-      return oppositeIndex - arrayLength;
-    } else {
-      return oppositeIndex;
-    }
-  }
-
-  static getRoundListOutboundIndex<T>(array: T[], index: number): T {
-    try {
-      while (array.length <= index) {
-        index -= array.length;
-      }
-  
-      while (index < 0) {
-        index += array.length;
-      }
-      
-      return array[index];
-    } catch (error) {
-      console.error(
-        'DyFM_Array.getRoundListOutboundIndex error:', error,
-        '\narray:', array,
-        '\nindex:', index
-      );
-      
-      return null;
-    }
-  } */
-}
+
+
+/**
+ * This class is a collection of static methods for round list operations
+ * A round list is a list that is circular
+ * - after the last element, the first comes next
+ */
+export class DyFM_RoundList {  
+  /**
+   * returns the outbound index of the list
+   * @param listLength 
+   * @param outboundIndex 
+   * @returns 
+   * 
+   * @example
+   * ```ts
+   * const listLength = 10;
+   * const outboundIndex = 15;
+   * const result = DyFM_RoundList.getOutboundedIndex(listLength, outboundIndex);
+   * console.log(result); // 5
+   * ```
+   */
+  static getOutboundedIndex(listLength: number, outboundIndex: number): number {
+    if (!listLength) {
+      throw new Error('roundListPlusIndex failed. list is empty!');
+    }
+  
+    if (outboundIndex < 0) {
+      outboundIndex = outboundIndex % listLength;
+      outboundIndex = listLength + outboundIndex;
+    }
+    
+    if (listLength <= outboundIndex) {
+      outboundIndex = outboundIndex % listLength;
+    }
+  
+    return outboundIndex;
+  }
+  
+  /**
+   * returns the index of the opposite element of the list
+   * - as they are circular, the opposite is at the half of the list
+   * - as it is circular, for the second half, the opposite is at the first half
+   * @param length 
+   * @param oppositeOf 
+   * @returns 
+   * 
+   * @example
+   * ```ts
+   * const length = 10;
+   * const oppositeOf = 5;
+   * const result = DyFM_RoundList.getIndexOpposite(length, oppositeOf);
+   * console.log(result); // 0
+   * ```
+   */
+  static getIndexOpposite(length: number, oppositeOf: number): number {
+    const plusIndex = oppositeOf + Math.round(length / 2);
+    const res = this.getOutboundedIndex(length, plusIndex);
+  
+    return res;
+  }
+  
+  /**
+   * returns the element at the outbound index of the list
+   * @param list 
+   * @param outboundIndex 
+   * @returns 
+   * 
+   * @example
+   * ```ts
+   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+   * const outboundIndex = 15;
+   * const result = DyFM_RoundList.getListIndex(list, outboundIndex);
+   * console.log(result); // 5
+   * ```
+   */
+  static getListIndex<T>(list: T[], outboundIndex: number): T {
+    return list[this.getOutboundedIndex(list.length, outboundIndex)];
+  }
+  
+  /**
+   * returns the element at the opposite index of the list
+   * @param list 
+   * @param oppositeOf 
+   * @returns 
+   * 
+   * @example
+   * ```ts
+   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+   * const oppositeOf = 5;
+   * const result = DyFM_RoundList.getListOpposite(list, oppositeOf);
+   * console.log(result); // 0
+   * ```
+   */
+  static getListOpposite<T>(list: T[], oppositeOf: T): T {
+    return list[this.getIndexOpposite(list.length, list.indexOf(oppositeOf))];
+  }
+  
+  /**
+   * returns the last element of the list
+   * returns null if the list is empty
+   * 
+   * @example
+   * ```ts
+   * const list = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+   * const result = DyFM_RoundList.getLast(list);
+   * console.log(result); // 10
+   * ```
+   */
+  static getLast<T>(list: T[]): T | null {
+    if (0 < list.length) {
+      return list[list.length - 1];
+    } else {
+      return null;
+    }
+  }
+
+  /** 
+   * returns the opposite index as they circular
+   * so after the last index, the first comes next
+   * an array that has 8 elements, the opposite of 7 is 3
+   * */
+  /* static getRoundListOppositeIndex(
+    arrayLength: number, 
+    index: number, 
+    roundUp: boolean = false
+  ): number {
+    const oppositeIndex = index + (
+      roundUp ? 
+        Math.ceil(arrayLength / 2) : 
+        Math.floor(arrayLength / 2)
+    );
+
+    if (arrayLength <= oppositeIndex) {
+      return oppositeIndex - arrayLength;
+    } else {
+      return oppositeIndex;
+    }
+  }
+
+  static getRoundListOutboundIndex<T>(array: T[], index: number): T {
+    try {
+      while (array.length <= index) {
+        index -= array.length;
+      }
+  
+      while (index < 0) {
+        index += array.length;
+      }
+      
+      return array[index];
+    } catch (error) {
+      console.error(
+        'DyFM_Array.getRoundListOutboundIndex error:', error,
+        '\narray:', array,
+        '\nindex:', index
+      );
+      
+      return null;
+    }
+  } */
+}