@futdevpro/fsm-dynamo 1.7.3 → 1.7.5

package/src/_utils/array.util.ts

@@ -1,15 +1,22 @@
+import { Dynamo_Paged } from '../_models/interfaces/paged.interace';
 
 
 export type D_Array = Dynamo_Array;
 export class Dynamo_Array {  
 
-  static async asyncForEach<T>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<void>): Promise<void> {
+  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 asyncMapArray<T, R>(list: T[], mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>): Promise<R[]> {
+  static async asyncMapArray<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++) {
@@ -29,7 +36,10 @@ export class Dynamo_Array {
     return array;
   }
 
-  static findNRemove<T>(array: T[], func: (element: T, index?: number, array?: T[]) => boolean): T[] {
+  static findNRemove<T>(
+    array: T[], 
+    func: (element: T, index?: number, array?: T[]) => boolean
+  ): T[] {
     const index = array.findIndex(func);
 
     if (-1 < index) {
@@ -38,6 +48,41 @@ export class Dynamo_Array {
 
     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): Dynamo_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;
+  }
+
 }
 
 

package/src/_utils/box-bounds.util.ts

@@ -0,0 +1,71 @@
+import { Vector2 } from './vector2.util';
+
+export class BoxBounds {
+  private _pos: Vector2;
+  set pos(value: Vector2) {
+    this._pos = value;
+
+    this.calcCenter();
+  }
+  get pos(): Vector2 { 
+    return this._pos;
+  }
+
+  private _size: Vector2;
+  set size(value: Vector2) {
+    this._size = value;
+    
+    this.calcCenter();
+  }
+  get size(): Vector2 { 
+    return this._size;
+  }
+
+  private _center: Vector2;
+  get center(): Vector2 {
+    return this._center;
+  }
+
+  constructor(
+    position: Vector2 = new Vector2(), 
+    size: Vector2 = new Vector2()
+  ) {
+    this._pos = position;
+    this._size = size;
+
+    this.calcCenter();
+  }
+
+  newValues(position: Vector2, size: Vector2): void {
+    if (position === undefined) {
+      throw new Error('new position is undefined!');
+    }
+
+    if (size === undefined) {
+      throw new Error('new size is undefined!');
+    }
+
+    this._pos = position;
+    this._size = size;
+
+    this.calcCenter();
+  }
+
+  static bounds(box: BoxBounds, position: Vector2): boolean {
+    return  box.pos.x <= position.x && position.x <= box.pos.x + box.size.x && 
+            box.pos.y <= position.y && position.y <= box.pos.y + box.size.y;
+  }
+  bounds(position: Vector2): boolean {
+    return BoxBounds.bounds(this, position);
+  }
+
+  private calcCenter(): void {
+    this._center = Vector2.plus(this.pos, Vector2.divide(this.size, 2));
+  }
+
+  clone(): BoxBounds {
+    return new BoxBounds(this.pos.clone(), this.size.clone());
+  }
+}
+
+

package/src/_utils/index.ts

@@ -1,8 +1,10 @@
 
 // TOOLS
 export * from './array.util';
+export * from './box-bounds.util';
 export * from './location.util';
 export * from './log.util';
+export * from './math.util';
 export * from './metadata.util';
 export * from './random.util';
 export * from './regex.util';
@@ -11,6 +13,7 @@ export * from './round-list.util';
 export * from './shared.static-service';
 export * from './time.util';
 export * from './trigonometry.util';
+export * from './type-cloning-facility.util';
 export * from './utilities.util';
 export * from './vector2.util';
 

package/src/_utils/location.util.ts

@@ -25,7 +25,11 @@ export class Dynamo_Location {
     return R * c;
   }
 
-  static getLocationDegByKilometers(latiOrLong: 'latitude' | 'longitude', distanceInKm: number, latitude?: number): number {
+  static getLocationDegByKilometers(
+    latiOrLong: 'latitude' | 'longitude', 
+    distanceInKm: number, 
+    latitude?: number
+  ): number {
     if (latiOrLong === 'latitude') {
       return distanceInKm / 110.574;
     } else {
@@ -36,8 +40,12 @@ export class Dynamo_Location {
           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.`
+          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.`
         });
       }
     }

package/src/_utils/log.util.ts

@@ -10,7 +10,8 @@ export class Dynamo_Log {
 
   static setStyle(styles: Dynamo_LogStyle[]): void {
     let styleSets = '';
-    styles.forEach((style: Dynamo_LogStyle) => {
+
+    styles.forEach((style: Dynamo_LogStyle): void => {
       styleSets += style;
     });
     console.log(styleSets);
@@ -21,61 +22,79 @@ export class Dynamo_Log {
 
   static addStyle(input: string, styles: Dynamo_LogStyle[], dontReset?: boolean): string {
     let result = '';
-    styles.forEach((style: Dynamo_LogStyle) => {
+
+    styles.forEach((style: Dynamo_LogStyle): void => {
       result += style;
     });
     result += input;
+
     if (!dontReset) {
       result += Dynamo_LogStyle.reset;
     }
+
     return result;
   }
 
   static success(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.log(`${Dynamo_LogStyle.green}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
+      console.log(
+        `${Dynamo_LogStyle.green}${Dynamo_LogStyle.bright}${message}`, 
+        ...optionalParams, Dynamo_LogStyle.reset
+      );
     } else {
-      console.log(`${Dynamo_LogStyle.green}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
+      console.log(
+        `${Dynamo_LogStyle.green}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`
+      );
     }
   }
   /** 
    * @deprecated use Dynamo_Log.success instead
    */
-  static logSuccess(message: string, ...optionalParams: any[]) {
+  static logSuccess(message: string, ...optionalParams: any[]): void {
     this.success(message, ...optionalParams);
   } 
 
   static error(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.error(`${Dynamo_LogStyle.red}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
+      console.error(
+        `${Dynamo_LogStyle.red}${Dynamo_LogStyle.bright}${message}`,
+        ...optionalParams, Dynamo_LogStyle.reset
+      );
     } else {
-      console.error(`${Dynamo_LogStyle.red}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
+      console.error(
+        `${Dynamo_LogStyle.red}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`
+      );
     }
   }
   /** 
    * @deprecated use Dynamo_Log.error instead
    */
-  static logError(message: string, ...optionalParams: any[]) {
+  static logError(message: string, ...optionalParams: any[]): void {
     this.error(message, ...optionalParams);
   }
 
   static warn(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.warn(`${Dynamo_LogStyle.yellow}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
+      console.warn(
+        `${Dynamo_LogStyle.yellow}${Dynamo_LogStyle.bright}${message}`, 
+        ...optionalParams, Dynamo_LogStyle.reset
+      );
     } else {
-      console.warn(`${Dynamo_LogStyle.yellow}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
+      console.warn(
+        `${Dynamo_LogStyle.yellow}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`
+      );
     }
   }
   /** 
    * @deprecated use Dynamo_Log.warn instead
    */
-  static warning(message: string, ...optionalParams: any[]) {
+  static warning(message: string, ...optionalParams: any[]): void {
     this.warn(message, ...optionalParams);
   }
   /** 
    * @deprecated use Dynamo_Log.warn instead
    */
-  static logWarning(message: string, ...optionalParams: any[]) {
+  static logWarning(message: string, ...optionalParams: any[]): void {
     this.warn(message, ...optionalParams);
   }
 
@@ -89,9 +108,14 @@ export class Dynamo_Log {
 
   static highlighted(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.log(`${Dynamo_LogStyle.white}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
+      console.log(
+        `${Dynamo_LogStyle.white}${Dynamo_LogStyle.bright}${message}`, 
+        ...optionalParams, Dynamo_LogStyle.reset
+      );
     } else {
-      console.log(`${Dynamo_LogStyle.white}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
+      console.log(
+        `${Dynamo_LogStyle.white}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`
+      );
     }
   }
   static testLog(message: string, ...optionalParams: any[]): void {
@@ -180,32 +204,36 @@ export class Dynamo_Log {
   } 
   static H_success = Dynamo_Log.highlightedSuccess;
 
+  // eslint-disable-next-line max-len
   private static h_solid: string =  '|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||';
+  // eslint-disable-next-line max-len
   private static h_before: string = '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\';
+  // eslint-disable-next-line max-len
   private static h_after: string =  '/////////////////////////////////////////////////////////////////////////////';
 
   static removeLogStyles(message: string): string {
-    for (let styleKey of Object(Dynamo_LogStyle)) {
+    for (const styleKey of Object(Dynamo_LogStyle)) {
       message = message.replace(new RegExp(Dynamo_LogStyle[styleKey], 'g'), '');
     }
+
     return message;
   }
 
   static silenceLogs(): void {
-    console.log = () => {};
+    console.log = (): void => {};
   }
 
   static silenceNonErrorLogs(): void {
-    console.log = () => {};
-    console.info = () => {};
-    console.warn = () => {};
+    console.log = (): void => {};
+    console.info = (): void => {};
+    console.warn = (): void => {};
   }
   
   static silenceConsole(): void {
-    console.log = () => {};
-    console.info = () => {};
-    console.warn = () => {};
-    console.error = () => {};
+    console.log = (): void => {};
+    console.info = (): void => {};
+    console.warn = (): void => {};
+    console.error = (): void => {};
   }
 }
 

package/src/_utils/math.util.ts

@@ -0,0 +1,53 @@
+
+
+
+
+
+
+
+
+
+export class Dynamo_Math {
+
+  static between(value: number, minExclusive: number, maxExclusive: number): boolean {
+    return minExclusive < value && value < maxExclusive;
+  }
+
+  static around(value: number, target: number, range: number): boolean {
+    return this.between(value, target - range, target + range);
+  }
+
+  static getRandomInt(min: number, max: number): number {
+    return min + Math.round((max - min) * Math.random());
+  }
+
+  static round(value: number, decimals: number = 2): number {
+    return Number(value.toFixed(decimals));
+  }
+
+  static numberWithSpaces(x: number): string {
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+  }
+
+  static floatingNumberWithSpaces(x: number): string {
+    const parts: string[] = x.toString().split('.');
+
+    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+
+    return parts.join('.');
+  }
+
+  static decimals(x: number, useSpacer: string = ','): string {
+    const parts: string[] = x.toString().split('.');
+
+    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, useSpacer);
+
+    return parts.join('.');
+  }
+}
+
+
+
+
+
+

package/src/_utils/metadata.util.ts

@@ -15,6 +15,7 @@ export class Dynamo_Metadata_Tool {
     if (!data.__created) {
       data.__created = new Date();
     }
+    
     if (!data.__createdBy) {
       data.__createdBy = issuer;
     }

package/src/_utils/random.util.ts

@@ -4,18 +4,22 @@ import { RandomWeight } from '../_models/interfaces/random-weight.interface';
 export type D_Random = Dynamo_Random;
 export class Dynamo_Random {
   static getRandomWeightedInt(min: number, max: number, weights: RandomWeight<number>[]): number {
-    weights = weights.sort((a, b) => b.chance - a.chance);
+    weights = weights.sort((a, b): number => b.chance - a.chance);
     let weightChanceSum = 0;
-    weights.forEach(weight => weightChanceSum += weight.chance);
+
+    weights.forEach((weight): void => { weightChanceSum += weight.chance; });
+
     if (1 < weightChanceSum) {
-      weights.forEach(weights => weights.chance = weights.chance / weightChanceSum);
+      weights.forEach((weights): void => { weights.chance = weights.chance / weightChanceSum; });
     }
   
     const randomChance: number = Math.random();
     let result: number;
     let chancer = 0;
+
     for (let i = 0; i < weights.length && result === undefined; i++) {
       chancer += weights[i].chance;
+
       if (randomChance < chancer) {
         result = weights[i].result;
       }
@@ -45,21 +49,28 @@ export class Dynamo_Random {
       return null;
     }
   
-    weights = weights.sort((a, b) => b.chance - a.chance);
+    weights = weights.sort((a, b): number => b.chance - a.chance);
     let weightChanceSum = 0;
-    weights.forEach(weight => weightChanceSum += weight.chance);
-    weights.forEach(weights => weights.chance = weights.chance / weightChanceSum);
+
+    weights.forEach((weight): void => { 
+      weightChanceSum += weight.chance; 
+    });
+    weights.forEach((weights): void => { 
+      weights.chance = weights.chance / weightChanceSum; 
+    });
   
     const randomChance: number = Math.random();
     let result: T;
     let chancer = 0;
+
     for (let i = 0; i < weights.length && result === undefined; i++) {
       chancer += weights[i].chance;
+
       if (randomChance < chancer) {
         result = weights[i].result;
       }
     }
   
-    return result
+    return result;
   }
 }

package/src/_utils/regex/password-regex.util.ts

@@ -0,0 +1,53 @@
+
+export const Dynamo_passwordRegex: RegExp = new RegExp(
+  '^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*]){6,}'
+);
+
+/* export const Dynamo_ALLPasswordRegexUserMessages: string = 
+  'Password must include at least one lowercase letter. ' +
+  'Password must include at least one uppercase letter.' +
+  'Password must include at least one digit.' +
+  'Password must include at least one of the !@#$%^&* characters.' +
+  'Password must be at least 6 characters long.'; */
+
+export function getPasswordErrors(password: string): string[] {
+  const errors: string[] = [];
+
+  passwordErrorsOneByOne.forEach((error) => {
+    if (!error.regex.test(password)) {
+      errors.push(error.message);
+    }
+  });
+
+  return errors;
+}
+
+const passwordErrorsOneByOne = [
+  {
+    regex: new RegExp('^(?=.*[a-z])'),
+    code: 'pwErrorLowercase',
+    message: 'Password must include at least one lowercase letter.'
+  },
+  {
+    regex: new RegExp('^(?=.*[A-Z])'),
+    code: 'pwErrorUppercase',
+    message: 'Password must include at least one uppercase letter.'
+  },
+  {
+    regex: new RegExp('^(?=.*[0-9])'),
+    code: 'pwErrorDigit',
+    message: 'Password must include at least one digit.'
+  },
+  {
+    regex: new RegExp('^(?=.*[!@#$%^&*])'),
+    code: 'pwErrorSpecialChar',
+    message: 'Password must include at least one of the !@#$%^&* characters.'
+  },
+  {
+    regex: new RegExp('^(?=.{6,})'),
+    code: 'pwErrorLength',
+    message: 'Password must be at least 6 characters long.'
+  },
+];
+
+//'!@#$%^&*+-_<>?.,;:|~'

package/src/_utils/regex/username-regex.util.ts

@@ -0,0 +1,33 @@
+
+export const FDP_usernameRegex: RegExp = new RegExp('^[a-zA-Z0-9-_#$%&^|*]{6,}$');
+
+/* export const FDP_usernameRegexUserMessage: string =
+  'Username must be at least 6 characters long and can only contain letters, ' +
+  'numbers, and the following special characters: -_#$%&^|*'; */
+
+/* export function getUsernameErrors(username: string): string[] {
+  const errors: string[] = [];
+
+  usernameErrorsOneByOne.forEach((error) => {
+    if (!error.regex.test(username)) {
+      errors.push(error.message);
+    }
+  });
+
+  return errors;
+} */
+
+const usernameErrorsOneByOne = [
+  {
+    regex: new RegExp('^(?=.{6,})'),
+    code: 'usernameErrorLength',
+    /* message: 'Username must be at least 6 characters long.' */
+  },
+  {
+    regex: new RegExp('^(?=.*[a-zA-Z0-9-_#$%&^|*])'),
+    code: 'usernameErrorSpecialChar',
+    /* message: 
+      'Username can only contain letters, numbers, and the following special characters: -_#$%&^|*' */
+  },
+];
+

package/src/_utils/regex.util.ts

@@ -1,4 +1,4 @@
 
 
-export const emailRegex: RegExp = new RegExp('^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$');
+export const emailRegex: RegExp = new RegExp('^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+$');
 

package/src/_utils/regions.util.ts

@@ -25,20 +25,26 @@ export class Dynamo_Regions {
   private static getAllPhoneCodes(): CountryPhoneCode[] {
     return JSONListify(PhoneCodes);
   }
- /*  private static getSubdivisionCollection(): DivisionCollection {
+
+  /*  private static getSubdivisionCollection(): DivisionCollection {
     return Divisions as DivisionCollection;
   } */
   private static getAllCountryISO(): CountryISO[] {
     const result: CountryISO[] = JSONListify(ISOs);
-    result.forEach((iso: CountryISO) => {
-      iso.phoneCode = this.phoneCodes.find((pc: CountryPhoneCode) => pc.iso === iso.iso2)?.code;
-      iso.divisions = this.divisions.filter((d: CountryDivision) => d.iso === iso.iso2);
+
+    result.forEach((iso: CountryISO): void => {
+      iso.phoneCode = this.phoneCodes.find(
+        (pc: CountryPhoneCode): boolean => pc.iso === iso.iso2
+      )?.code;
+      iso.divisions = this.divisions.filter((d: CountryDivision): boolean => d.iso === iso.iso2);
     });
+
     return result;
   }
 
   static isoToCountryIso(iso2: string): CountryISO {
-    const country: CountryISO = this.ISOs.find(iso => iso.iso2 == iso2);
+    const country: CountryISO = this.ISOs.find((iso: CountryISO): boolean => iso.iso2 == iso2);
+
     if (!country) {
       throw new Dynamo_Error({ 
         message: `Cannot find ISO-3166 code for this: ${iso2}` 
@@ -49,7 +55,10 @@ export class Dynamo_Regions {
   }
 
   static isoToRegion(iso2: string): Dynamo_Region {
-    const region: Dynamo_Region = this.ISOs.find(iso => iso.iso2 == iso2).region;
+    const region: Dynamo_Region = this.ISOs.find(
+      (iso: CountryISO): boolean => iso.iso2 == iso2
+    )?.region;
+
     if (!region) {
       throw new Dynamo_Error({ 
         message: `Cannot find ISO-3166 code for this: ${iso2}` 
@@ -60,7 +69,10 @@ export class Dynamo_Regions {
   }
 
   static isoToPhoneCode(iso2: string): CountryPhoneCode {
-    const phoneCode: CountryPhoneCode = this.phoneCodes.find(code => code.iso == iso2);
+    const phoneCode: CountryPhoneCode = this.phoneCodes.find(
+      (code: CountryPhoneCode): boolean => code.iso == iso2
+    );
+
     if (!phoneCode) {
       throw new Dynamo_Error({ 
         message: `Cannot find ISO-3166 code for this: ${iso2}` 

package/src/_utils/round-list.util.ts

@@ -11,6 +11,7 @@ export class Dynamo_RoundList {
       outboundIndex = outboundIndex % listLength;
       outboundIndex = listLength + outboundIndex;
     }
+    
     if (listLength <= outboundIndex) {
       outboundIndex = outboundIndex % listLength;
     }