@futdevpro/fsm-dynamo 1.9.9 → 1.9.12

package/src/_collections/utils/pipe-transforms/smart-replace-pipe.util.ts

@@ -1,71 +1,71 @@
-
-
-
-
-
-
-
-import { DynamoFM_MultiPipe_Setting } from '../../../_models/interfaces/multi-pipe-settings.type';
-import { DynamoFM_multiPipe_pipeTransform } from './multi-pipe-pipe.util';
-
-
-/**
- * Replaces the keys from the replacer with the values from the replacer object.
- */
-export function DynamoFM_smartReplace_pipeTransform(
-  value: string, replacer: object, multiPipes?: DynamoFM_MultiPipe_Setting[]
-): string {
-
-  if (!replacer) {
-    console.warn(
-      'DYNAMO WARNING: ' +
-      '\nSmartReplacePipe: replaceTo is not defined...',
-      '\n\n',
-      new Error()
-    );
-
-    return value;
-  }
-
-  for (const key in replacer) {
-    if (replacer[key]?.value) {
-      if (!replacer[key]?.pipes) {
-        console.warn(
-          'DYNAMO WARNING: ' +
-          '\nSmartReplacePipe: replaceTo[' + key + '].multiPipe is not defined...',
-          '\n\n',
-          new Error()
-        );
-
-        return;
-      }
-
-      if (!Array.isArray(replacer[key].pipes)) {
-        console.warn(
-          'DYNAMO WARNING: ' +
-          '\nSmartReplacePipe: replaceTo[' + key + '].multiPipe is not an array...',
-          '\n\n',
-          new Error()
-        );
-
-        return;
-      }
-
-      replacer[key] = DynamoFM_multiPipe_pipeTransform(
-        replacer[key].value,
-        replacer[key].pipes
-      );
-    }
-
-    if (multiPipes?.length) {
-      replacer[key] = DynamoFM_multiPipe_pipeTransform(
-        replacer[key],
-        multiPipes
-      );
-    }
-
-    value = value.replaceAll(`{${key}}`, replacer[key]);
-  }
-
-  return value;
-}
+
+
+
+
+
+
+
+import { DynamoFM_MultiPipe_Setting } from '../../../_models/interfaces/multi-pipe-settings.type';
+import { DynamoFM_multiPipe_pipeTransform } from './multi-pipe-pipe.util';
+
+
+/**
+ * Replaces the keys from the replacer with the values from the replacer object.
+ */
+export function DynamoFM_smartReplace_pipeTransform(
+  value: string, replacer: object, multiPipes?: DynamoFM_MultiPipe_Setting[]
+): string {
+
+  if (!replacer) {
+    console.warn(
+      'DYNAMO WARNING: ' +
+      '\nSmartReplacePipe: replaceTo is not defined...',
+      '\n\n',
+      new Error()
+    );
+
+    return value;
+  }
+
+  for (const key in replacer) {
+    if (replacer[key]?.value) {
+      if (!replacer[key]?.pipes) {
+        console.warn(
+          'DYNAMO WARNING: ' +
+          '\nSmartReplacePipe: replaceTo[' + key + '].multiPipe is not defined...',
+          '\n\n',
+          new Error()
+        );
+
+        return;
+      }
+
+      if (!Array.isArray(replacer[key].pipes)) {
+        console.warn(
+          'DYNAMO WARNING: ' +
+          '\nSmartReplacePipe: replaceTo[' + key + '].multiPipe is not an array...',
+          '\n\n',
+          new Error()
+        );
+
+        return;
+      }
+
+      replacer[key] = DynamoFM_multiPipe_pipeTransform(
+        replacer[key].value,
+        replacer[key].pipes
+      );
+    }
+
+    if (multiPipes?.length) {
+      replacer[key] = DynamoFM_multiPipe_pipeTransform(
+        replacer[key],
+        multiPipes
+      );
+    }
+
+    value = value.replaceAll(`{${key}}`, replacer[key]);
+  }
+
+  return value;
+}

package/src/_collections/utils/regex/index.ts

@@ -1,5 +1,5 @@
-
-
-export * from './password-regex.util';
-export * from './regex.util';
+
+
+export * from './password-regex.util';
+export * from './regex.util';
 export * from './username-regex.util';

package/src/_collections/utils/regex/password-regex.util.ts

@@ -1,53 +1,53 @@
-
-export const DynamoFM_passwordRegex: RegExp = new RegExp(
-  '^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*]){6,}'
-);
-
-/* export const DynamoFM_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 DynamoFM_getPasswordErrors(password: string): string[] {
-  const errors: string[] = [];
-
-  DynamoFM_passwordErrorsOneByOne.forEach((error): void => {
-    if (!error.regex.test(password)) {
-      errors.push(error.message);
-    }
-  });
-
-  return errors;
-}
-
-const DynamoFM_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.'
-  },
-];
-
+
+export const DynamoFM_passwordRegex: RegExp = new RegExp(
+  '^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*]){6,}'
+);
+
+/* export const DynamoFM_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 DynamoFM_getPasswordErrors(password: string): string[] {
+  const errors: string[] = [];
+
+  DynamoFM_passwordErrorsOneByOne.forEach((error): void => {
+    if (!error.regex.test(password)) {
+      errors.push(error.message);
+    }
+  });
+
+  return errors;
+}
+
+const DynamoFM_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/_collections/utils/regex/regex.util.ts

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

package/src/_collections/utils/regex/username-regex.util.ts

@@ -1,33 +1,33 @@
-
-export const DynamoFM_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 DynamoFM_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: -_#$%&^|*' */
-  },
-];
-
+
+export const DynamoFM_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 DynamoFM_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/_collections/utils/regions.util.ts

@@ -1,97 +1,100 @@
-
-import * as ISOs from '../assets/location/country-codes-ISO-3166.json';
-
-import * as PhoneCodes from '../assets/location/country-phone-codes.json';
-import * as Divisions from '../assets/location/country-divisions-ISO-3166-all-list.json';
-
-import { DynamoFM_Region } from '../../_enums/location/region.enum';
-import { DynamoFM_Error } from '../../_models';
-import { 
-  DynamoFM_CountryPhoneCode 
-} from '../../_models/interfaces/location/country-phone-code.interface';
-import { DynamoFM_CountryISO } from '../../_models/interfaces/location/country-iso.interface';
-import { DynamoFM_CountryDivision } from '../../_models/interfaces/location/country-division.interface';
-
-import { DynamoFM_JSONListify } from './utilities.util';
-
-export type DFM_Regions = DynamoFM_Regions;
-export class DynamoFM_Regions {
-  /* static divisions: DivisionCollection = DynamoFM_Regions.getSubdivisionCollection(); */
-  static divisions: DynamoFM_CountryDivision[] = DynamoFM_Regions.getAllDivisions();
-  static phoneCodes: DynamoFM_CountryPhoneCode[] = DynamoFM_Regions.getAllPhoneCodes();
-  static countryISOs: DynamoFM_CountryISO[] = DynamoFM_Regions.getAllCountryISO();
-
-  private static getAllDivisions(): DynamoFM_CountryDivision[] {
-    if (!Divisions) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
-
-    return DynamoFM_JSONListify(Divisions);
-  }
-  private static getAllPhoneCodes(): DynamoFM_CountryPhoneCode[] {
-    if (!PhoneCodes) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
-    
-    return DynamoFM_JSONListify(PhoneCodes);
-  }
-
-  /*  private static getSubdivisionCollection(): DivisionCollection {
-    return Divisions as DivisionCollection;
-  } */
-  private static getAllCountryISO(): DynamoFM_CountryISO[] {
-    if (!ISOs) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
-
-    const result: DynamoFM_CountryISO[] = DynamoFM_JSONListify(ISOs);
-
-    result.forEach((iso: DynamoFM_CountryISO): void => {
-      iso.phoneCode = this.phoneCodes.find(
-        (pc: DynamoFM_CountryPhoneCode): boolean => pc.iso === iso.iso2
-      )?.code;
-      iso.divisions = this.divisions.filter(
-        (d: DynamoFM_CountryDivision): boolean => d.iso === iso.iso2
-      );
-    });
-
-    return result;
-  }
-
-  static isoToCountryIso(iso2: string): DynamoFM_CountryISO {
-    const country: DynamoFM_CountryISO = this.countryISOs.find(
-      (iso: DynamoFM_CountryISO): boolean => iso.iso2 == iso2
-    );
-
-    if (!country) {
-      throw new DynamoFM_Error({ 
-        message: `Cannot find ISO-3166 code for this: ${iso2}`,
-      });
-    } else {
-      return country;
-    }
-  }
-
-  static isoToRegion(iso2: string): DynamoFM_Region {
-    const region: DynamoFM_Region = this.countryISOs.find(
-      (iso: DynamoFM_CountryISO): boolean => iso.iso2 == iso2
-    )?.region;
-
-    if (!region) {
-      throw new DynamoFM_Error({ 
-        message: `Cannot find ISO-3166 code for this: ${iso2}`,
-      });
-    } else {
-      return region;
-    }
-  }
-
-  static isoToPhoneCode(iso2: string): DynamoFM_CountryPhoneCode {
-    const phoneCode: DynamoFM_CountryPhoneCode = this.phoneCodes.find(
-      (code: DynamoFM_CountryPhoneCode): boolean => code.iso == iso2
-    );
-
-    if (!phoneCode) {
-      throw new DynamoFM_Error({ 
-        message: `Cannot find ISO-3166 code for this: ${iso2}`,
-      });
-    } else {
-      return phoneCode;
-    }
-  }
-}
-
+
+/* const ISOs = [];
+const PhoneCodes = [];
+const Divisions = []; */
+import * as ISOs from '../assets/location/country-codes-ISO-3166.json';
+
+import * as PhoneCodes from '../assets/location/country-phone-codes.json';
+import * as Divisions from '../assets/location/country-divisions-ISO-3166-all-list.json';
+
+import { DynamoFM_Region } from '../../_enums/location/region.enum';
+import { DynamoFM_Error } from '../../_models';
+import { 
+  DynamoFM_CountryPhoneCode 
+} from '../../_models/interfaces/location/country-phone-code.interface';
+import { DynamoFM_CountryISO } from '../../_models/interfaces/location/country-iso.interface';
+import { DynamoFM_CountryDivision } from '../../_models/interfaces/location/country-division.interface';
+
+import { DynamoFM_JSONListify } from './utilities.util';
+
+export type DFM_Regions = DynamoFM_Regions;
+export class DynamoFM_Regions {
+  /* static divisions: DivisionCollection = DynamoFM_Regions.getSubdivisionCollection(); */
+  static divisions: DynamoFM_CountryDivision[] = DynamoFM_Regions.getAllDivisions();
+  static phoneCodes: DynamoFM_CountryPhoneCode[] = DynamoFM_Regions.getAllPhoneCodes();
+  static countryISOs: DynamoFM_CountryISO[] = DynamoFM_Regions.getAllCountryISO();
+
+  private static getAllDivisions(): DynamoFM_CountryDivision[] {
+    if (!Divisions) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
+
+    return DynamoFM_JSONListify(Divisions);
+  }
+  private static getAllPhoneCodes(): DynamoFM_CountryPhoneCode[] {
+    if (!PhoneCodes) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
+    
+    return DynamoFM_JSONListify(PhoneCodes);
+  }
+
+  /*  private static getSubdivisionCollection(): DivisionCollection {
+    return Divisions as DivisionCollection;
+  } */
+  private static getAllCountryISO(): DynamoFM_CountryISO[] {
+    if (!ISOs) throw new DynamoFM_Error({ message: 'Cannot find ISO-3166 JSON file.' });
+
+    const result: DynamoFM_CountryISO[] = DynamoFM_JSONListify(ISOs);
+
+    result.forEach((iso: DynamoFM_CountryISO): void => {
+      iso.phoneCode = this.phoneCodes.find(
+        (pc: DynamoFM_CountryPhoneCode): boolean => pc.iso === iso.iso2
+      )?.code;
+      iso.divisions = this.divisions.filter(
+        (d: DynamoFM_CountryDivision): boolean => d.iso === iso.iso2
+      );
+    });
+
+    return result;
+  }
+
+  static isoToCountryIso(iso2: string): DynamoFM_CountryISO {
+    const country: DynamoFM_CountryISO = this.countryISOs.find(
+      (iso: DynamoFM_CountryISO): boolean => iso.iso2 == iso2
+    );
+
+    if (!country) {
+      throw new DynamoFM_Error({ 
+        message: `Cannot find ISO-3166 code for this: ${iso2}`,
+      });
+    } else {
+      return country;
+    }
+  }
+
+  static isoToRegion(iso2: string): DynamoFM_Region {
+    const region: DynamoFM_Region = this.countryISOs.find(
+      (iso: DynamoFM_CountryISO): boolean => iso.iso2 == iso2
+    )?.region;
+
+    if (!region) {
+      throw new DynamoFM_Error({ 
+        message: `Cannot find ISO-3166 code for this: ${iso2}`,
+      });
+    } else {
+      return region;
+    }
+  }
+
+  static isoToPhoneCode(iso2: string): DynamoFM_CountryPhoneCode {
+    const phoneCode: DynamoFM_CountryPhoneCode = this.phoneCodes.find(
+      (code: DynamoFM_CountryPhoneCode): boolean => code.iso == iso2
+    );
+
+    if (!phoneCode) {
+      throw new DynamoFM_Error({ 
+        message: `Cannot find ISO-3166 code for this: ${iso2}`,
+      });
+    } else {
+      return phoneCode;
+    }
+  }
+}
+

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

@@ -1,44 +1,44 @@
-
-
-export type DFM_RoundList = DynamoFM_RoundList;
-export class DynamoFM_RoundList {  
-  static getOutboundedIndex(listLength: number, outboundIndex: number): number {
-    if (!(0 < 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;
-  }
-  
-  static getIndexOpposite(length: number, oppositeOf: number): number {
-    const plusIndex = oppositeOf + Math.round(length / 2);
-    const res = this.getOutboundedIndex(length, plusIndex);
-  
-    return res;
-  }
-  
-  static getListIndex<T>(list: T[], outboundIndex: number): T {
-    return list[this.getOutboundedIndex(list.length, outboundIndex)];
-  }
-  
-  static getListOpposite<T>(list: T[], oppositeOf: T): T {
-    return list[this.getIndexOpposite(list.length, list.indexOf(oppositeOf))];
-  }
-  
-  static getLast<T>(list: T[]): T {
-    if (0 < list.length) {
-      return list[list.length - 1];
-    } else {
-      return null;
-    }
-  }
-}
+
+
+export type DFM_RoundList = DynamoFM_RoundList;
+export class DynamoFM_RoundList {  
+  static getOutboundedIndex(listLength: number, outboundIndex: number): number {
+    if (!(0 < 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;
+  }
+  
+  static getIndexOpposite(length: number, oppositeOf: number): number {
+    const plusIndex = oppositeOf + Math.round(length / 2);
+    const res = this.getOutboundedIndex(length, plusIndex);
+  
+    return res;
+  }
+  
+  static getListIndex<T>(list: T[], outboundIndex: number): T {
+    return list[this.getOutboundedIndex(list.length, outboundIndex)];
+  }
+  
+  static getListOpposite<T>(list: T[], oppositeOf: T): T {
+    return list[this.getIndexOpposite(list.length, list.indexOf(oppositeOf))];
+  }
+  
+  static getLast<T>(list: T[]): T {
+    if (0 < list.length) {
+      return list[list.length - 1];
+    } else {
+      return null;
+    }
+  }
+}