@futdevpro/fsm-dynamo 1.9.9 → 1.9.12

package/src/_collections/utils/array.util.ts

@@ -1,137 +1,137 @@
-
-import { DynamoFM_Paged } from '../../_models/interfaces/paged.interface';
-
-export type DFM_Array = DynamoFM_Array;
-export class DynamoFM_Array {  
-
-  static async asyncForEach<T>(
-    list: T[], 
-    func: (element: T, index?: number, array?: T[]) => Promise<void>
-  ): Promise<void> {
-    for (let i = 0; i < list.length; i++) {
-      await func(list[i], i, list);
-    }
-  }
-  
-  static async asyncMap<T, R>(
-    list: T[], 
-    mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>
-  ): Promise<R[]> {
-    const resultList: R[] = [];
-
-    for (let i = 0; i < list.length; i++) {
-      resultList.push(await mapFunc(list[i], i, list));
-    }
-    
-    return resultList;
-  }
-
-  static last<T>(array: T[]): T {
-    return array.length ? array[array.length - 1] : null;
-  }
-
-  static remove<T>(array: T[], element: T): T[] {
-    const index = array.indexOf(element);
-
-    if (-1 < index) {
-      array.splice(index, 1);
-    }
-
-    return array;
-  }
-
-  static findNRemove<T>(
-    array: T[], 
-    func: (element: T, index?: number, array?: T[]) => boolean
-  ): T[] {
-    const index = array.findIndex(func);
-
-    if (-1 < index) {
-      array.splice(index, 1);
-    }
-
-    return array;
-  }
-
-  static shuffle<T>(array: T[]): T[] {
-    let currentIndex = array.length;
-    let randomIndex: number;
-
-    while (0 < currentIndex) {
-      randomIndex = Math.floor(Math.random() * currentIndex);
-      currentIndex--;
-
-      [ array[currentIndex], array[randomIndex] ] = [ array[randomIndex], array[currentIndex] ];
-    }
-
-    return array;
-  }
-
-  static page<T>(array: T[], pageIndex: number, pageSize: number): T[] {
-    return array.slice(pageIndex * pageSize, (pageIndex + 1) * pageSize);
-  }
-
-  static paged<T>(array: T[], pageIndex: number, pageSize: number): DynamoFM_Paged<T> {
-    return {
-      pageIndex,
-      pageSize,
-      total: array.length,
-      totalPageCount: Math.ceil(array.length / pageSize),
-      items: this.page(array, pageIndex, pageSize)
-    };
-  }
-
-  static swap<T>(array: T[], indexA: number, indexB: number): T[] {
-    [ array[indexA], array[indexB] ] = [ array[indexB], array[indexA] ];
-    
-    return array;
-  }
-
-  /** 
-   * 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;
-    }
-  }
-
-  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(
-        'DynamoFM_Array.getRoundListOutboundIndex error:', error,
-        '\narray:', array,
-        '\nindex:', index
-      );
-      
-      return null;
-    }
-  }
-
-}
-
-
+
+import { DynamoFM_Paged } from '../../_models/interfaces/paged.interface';
+
+export type DFM_Array = DynamoFM_Array;
+export class DynamoFM_Array {  
+
+  static async asyncForEach<T>(
+    list: T[], 
+    func: (element: T, index?: number, array?: T[]) => Promise<void>
+  ): Promise<void> {
+    for (let i = 0; i < list.length; i++) {
+      await func(list[i], i, list);
+    }
+  }
+  
+  static async asyncMap<T, R>(
+    list: T[], 
+    mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>
+  ): Promise<R[]> {
+    const resultList: R[] = [];
+
+    for (let i = 0; i < list.length; i++) {
+      resultList.push(await mapFunc(list[i], i, list));
+    }
+    
+    return resultList;
+  }
+
+  static last<T>(array: T[]): T {
+    return array.length ? array[array.length - 1] : null;
+  }
+
+  static remove<T>(array: T[], element: T): T[] {
+    const index = array.indexOf(element);
+
+    if (-1 < index) {
+      array.splice(index, 1);
+    }
+
+    return array;
+  }
+
+  static findNRemove<T>(
+    array: T[], 
+    func: (element: T, index?: number, array?: T[]) => boolean
+  ): T[] {
+    const index = array.findIndex(func);
+
+    if (-1 < index) {
+      array.splice(index, 1);
+    }
+
+    return array;
+  }
+
+  static shuffle<T>(array: T[]): T[] {
+    let currentIndex = array.length;
+    let randomIndex: number;
+
+    while (0 < currentIndex) {
+      randomIndex = Math.floor(Math.random() * currentIndex);
+      currentIndex--;
+
+      [ array[currentIndex], array[randomIndex] ] = [ array[randomIndex], array[currentIndex] ];
+    }
+
+    return array;
+  }
+
+  static page<T>(array: T[], pageIndex: number, pageSize: number): T[] {
+    return array.slice(pageIndex * pageSize, (pageIndex + 1) * pageSize);
+  }
+
+  static paged<T>(array: T[], pageIndex: number, pageSize: number): DynamoFM_Paged<T> {
+    return {
+      pageIndex,
+      pageSize,
+      total: array.length,
+      totalPageCount: Math.ceil(array.length / pageSize),
+      items: this.page(array, pageIndex, pageSize)
+    };
+  }
+
+  static swap<T>(array: T[], indexA: number, indexB: number): T[] {
+    [ array[indexA], array[indexB] ] = [ array[indexB], array[indexA] ];
+    
+    return array;
+  }
+
+  /** 
+   * 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;
+    }
+  }
+
+  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(
+        'DynamoFM_Array.getRoundListOutboundIndex error:', error,
+        '\narray:', array,
+        '\nindex:', index
+      );
+      
+      return null;
+    }
+  }
+
+}
+
+

package/src/_collections/utils/index.ts

@@ -1,18 +1,18 @@
-
-export * from './math';
-export * from './pipe-transforms';
-export * from './regex';
-
-
-// TOOLS
-export * from './array.util';
-export * from './location.util';
-export * from './log.util';
-export * from './regions.util';
-export * from './round-list.util';
-export * from './shared.static-service';
-export * from './time.util';
-export * from './type-cloning-facility.util';
-export * from './utilities.util';
-
-
+
+export * from './math';
+export * from './pipe-transforms';
+export * from './regex';
+
+
+// TOOLS
+export * from './array.util';
+export * from './location.util';
+export * from './log.util';
+export * from './regions.util';
+export * from './round-list.util';
+export * from './shared.static-service';
+export * from './time.util';
+export * from './type-cloning-facility.util';
+export * from './utilities.util';
+
+

package/src/_collections/utils/location.util.ts

@@ -1,55 +1,55 @@
-
-import { DynamoFM_Error } from '../../_models/control-models/error.control-model';
-import { DynamoFM_Trigonometry } from './math/trigonometry.util';
-import { DynamoFM_LocationCoordinates } from '../../_models/interfaces/location/location-coordinates.interface';
-
-export type DFM_Location = DynamoFM_Location;
-export class DynamoFM_Location {
-  
-  static getDistanceInKilometres(
-    from: DynamoFM_LocationCoordinates,
-    to: DynamoFM_LocationCoordinates
-  ): number {
-
-    const R = 6371; // kilometres
-    const φ1 = DynamoFM_Trigonometry.angleToRadians(from.latitude);
-    const φ2 = DynamoFM_Trigonometry.angleToRadians(to.latitude);
-    const Δφ = DynamoFM_Trigonometry.angleToRadians(to.latitude - from.latitude);
-    const Δλ = DynamoFM_Trigonometry.angleToRadians(to.longitude - from.longitude);
-
-    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
-              Math.cos(φ1) * Math.cos(φ2) *
-              Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-
-    return R * c;
-  }
-
-  static getLocationDegByKilometers(
-    latiOrLong: 'latitude' | 'longitude', 
-    distanceInKm: number, 
-    latitude?: number
-  ): number {
-    if (latiOrLong === 'latitude') {
-      return distanceInKm / 110.574;
-    } else {
-      if (latitude) {
-        return distanceInKm / (Math.cos(DynamoFM_Trigonometry.angleToRadians(latitude)) * 111.320);
-      } else {
-        throw new DynamoFM_Error({ 
-          status: 417, 
-          errorCode: 'FSM-DSS-505',
-          addECToUserMsg: true,
-          message: 
-            `When using getLocationDegByKilometers for longitude, you need to give latitude! ` +
-            `(latiOrLong: ${latiOrLong}, distanceInKm: ${distanceInKm}, latitude: ${latitude})`,
-          userMessage: 
-            `We encountered an uncought BackEnd Error, ` +
-            `please contact the responsible development team.`
-        });
-      }
-    }
-  }
-}
-
-
+
+import { DynamoFM_Error } from '../../_models/control-models/error.control-model';
+import { DynamoFM_Trigonometry } from './math/trigonometry.util';
+import { DynamoFM_LocationCoordinates } from '../../_models/interfaces/location/location-coordinates.interface';
+
+export type DFM_Location = DynamoFM_Location;
+export class DynamoFM_Location {
+  
+  static getDistanceInKilometres(
+    from: DynamoFM_LocationCoordinates,
+    to: DynamoFM_LocationCoordinates
+  ): number {
+
+    const R = 6371; // kilometres
+    const φ1 = DynamoFM_Trigonometry.angleToRadians(from.latitude);
+    const φ2 = DynamoFM_Trigonometry.angleToRadians(to.latitude);
+    const Δφ = DynamoFM_Trigonometry.angleToRadians(to.latitude - from.latitude);
+    const Δλ = DynamoFM_Trigonometry.angleToRadians(to.longitude - from.longitude);
+
+    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
+              Math.cos(φ1) * Math.cos(φ2) *
+              Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+    return R * c;
+  }
+
+  static getLocationDegByKilometers(
+    latiOrLong: 'latitude' | 'longitude', 
+    distanceInKm: number, 
+    latitude?: number
+  ): number {
+    if (latiOrLong === 'latitude') {
+      return distanceInKm / 110.574;
+    } else {
+      if (latitude) {
+        return distanceInKm / (Math.cos(DynamoFM_Trigonometry.angleToRadians(latitude)) * 111.320);
+      } else {
+        throw new DynamoFM_Error({ 
+          status: 417, 
+          errorCode: 'FSM-DSS-505',
+          addECToUserMsg: true,
+          message: 
+            `When using getLocationDegByKilometers for longitude, you need to give latitude! ` +
+            `(latiOrLong: ${latiOrLong}, distanceInKm: ${distanceInKm}, latitude: ${latitude})`,
+          userMessage: 
+            `We encountered an uncought BackEnd Error, ` +
+            `please contact the responsible development team.`
+        });
+      }
+    }
+  }
+}
+
+