@futdevpro/fsm-dynamo 1.7.14 → 1.8.2

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

@@ -1,36 +1,36 @@
 
 
-import { Vector2 } from './vector2.util';
+import { Dynamo_Vector2 } from './vector2.util';
 
-export class BoxBounds {
-  private _pos: Vector2;
-  set pos(value: Vector2) {
+export class Dynamo_BoxBounds {
+  private _pos: Dynamo_Vector2;
+  set pos(value: Dynamo_Vector2) {
     this._pos = value;
 
     this.calcCenter();
   }
-  get pos(): Vector2 { 
+  get pos(): Dynamo_Vector2 { 
     return this._pos;
   }
 
-  private _size: Vector2;
-  set size(value: Vector2) {
+  private _size: Dynamo_Vector2;
+  set size(value: Dynamo_Vector2) {
     this._size = value;
     
     this.calcCenter();
   }
-  get size(): Vector2 { 
+  get size(): Dynamo_Vector2 { 
     return this._size;
   }
 
-  private _center: Vector2;
-  get center(): Vector2 {
+  private _center: Dynamo_Vector2;
+  get center(): Dynamo_Vector2 {
     return this._center;
   }
 
   constructor(
-    position: Vector2 = new Vector2(), 
-    size: Vector2 = new Vector2()
+    position: Dynamo_Vector2 = new Dynamo_Vector2(), 
+    size: Dynamo_Vector2 = new Dynamo_Vector2()
   ) {
     this._pos = position;
     this._size = size;
@@ -38,7 +38,11 @@ export class BoxBounds {
     this.calcCenter();
   }
 
-  newValues(position: Vector2, size: Vector2): void {
+  constructed?(): boolean { 
+    return true; 
+  }
+
+  newValues?(position: Dynamo_Vector2, size: Dynamo_Vector2): void {
     if (position === undefined) {
       throw new Error('new position is undefined!');
     }
@@ -53,20 +57,20 @@ export class BoxBounds {
     this.calcCenter();
   }
 
-  static bounds(box: BoxBounds, position: Vector2): boolean {
+  static bounds(box: Dynamo_BoxBounds, position: Dynamo_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);
+  bounds?(position: Dynamo_Vector2): boolean {
+    return Dynamo_BoxBounds.bounds(this, position);
   }
 
-  private calcCenter(): void {
-    this._center = Vector2.plus(this.pos, Vector2.divide(this.size, 2));
+  private calcCenter?(): void {
+    this._center = Dynamo_Vector2.plus(this.pos, Dynamo_Vector2.divide(this.size, 2));
   }
 
-  clone(): BoxBounds {
-    return new BoxBounds(this.pos.clone(), this.size.clone());
+  clone?(): Dynamo_BoxBounds {
+    return new Dynamo_BoxBounds(this.pos.clone(), this.size.clone());
   }
 }
 

package/src/_utils/location.util.ts

@@ -1,14 +1,14 @@
 
 import { Dynamo_Error } from '../_models/control-models/error.control-model';
 import { Dynamo_Trigonometry } from './trigonometry.util';
-import { LocationCoordinates } from '../_models/interfaces/location/location-coordinates.interface';
+import { Dynamo_LocationCoordinates } from '../_models/interfaces/location/location-coordinates.interface';
 
 export type D_Location = Dynamo_Location;
 export class Dynamo_Location {
   
   static getDistanceInKilometres(
-    from: LocationCoordinates,
-    to: LocationCoordinates
+    from: Dynamo_LocationCoordinates,
+    to: Dynamo_LocationCoordinates
   ): number {
 
     const R = 6371; // kilometres

package/src/_utils/metadata.util.ts

@@ -1,6 +1,6 @@
 import { Dynamo_Metadata } from '../_models';
 
-
+/* 
 export class Dynamo_Metadata_Tool {
 
   static updateMetadata<T extends Dynamo_Metadata>(data: T, issuer: string, id?: string): T {
@@ -28,3 +28,4 @@ export class Dynamo_Metadata_Tool {
   }
 }
 
+ */

package/src/_utils/random.util.ts

@@ -1,9 +1,9 @@
 
-import { RandomWeight } from '../_models/interfaces/random-weight.interface';
+import { Dynamo_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 {
+  static getRandomWeightedInt(min: number, max: number, weights: Dynamo_RandomWeight<number>[]): number {
     weights = weights.sort((a, b): number => b.chance - a.chance);
     let weightChanceSum = 0;
 
@@ -44,7 +44,7 @@ export class Dynamo_Random {
     }
   }
   
-  static getRandomWeighted<T>(weights: RandomWeight<T>[]): T {
+  static getRandomWeighted<T>(weights: Dynamo_RandomWeight<T>[]): T {
     if (!weights?.length) {
       return null;
     }

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

@@ -10,7 +10,7 @@ export const Dynamo_passwordRegex: RegExp = new RegExp(
   'Password must include at least one of the !@#$%^&* characters.' +
   'Password must be at least 6 characters long.'; */
 
-export function getPasswordErrors(password: string): string[] {
+export function Dynamo_getPasswordErrors(password: string): string[] {
   const errors: string[] = [];
 
   passwordErrorsOneByOne.forEach((error) => {

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

@@ -1,5 +1,5 @@
 
-export const FDP_usernameRegex: RegExp = new RegExp('^[a-zA-Z0-9-_#$%&^|*]{6,}$');
+export const Dynamo_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, ' +

package/src/_utils/regex.util.ts

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

package/src/_utils/regions.util.ts

@@ -6,44 +6,44 @@ import * as Divisions from '../_constants/location/country-divisions-ISO-3166-al
 
 import { Dynamo_Region } from '../_enums/region.enum';
 import { Dynamo_Error } from '../_models';
-import { CountryPhoneCode } from '../_models/interfaces/location/country-phone-code.interface';
-import { CountryISO } from '../_models/interfaces/location/country-iso.interface';
-import { CountryDivision } from '../_models/interfaces/location/country-division.interface';
+import { Dynamo_CountryPhoneCode } from '../_models/interfaces/location/country-phone-code.interface';
+import { Dynamo_CountryISO } from '../_models/interfaces/location/country-iso.interface';
+import { Dynamo_CountryDivision } from '../_models/interfaces/location/country-division.interface';
 
-import { JSONListify } from './utilities.util';
+import { Dynamo_JSONListify } from './utilities.util';
 
 export type D_Regions = Dynamo_Regions;
 export class Dynamo_Regions {
   /* static divisions: DivisionCollection = Dynamo_Regions.getSubdivisionCollection(); */
-  static divisions: CountryDivision[] = Dynamo_Regions.getAllDivisions();
-  static phoneCodes: CountryPhoneCode[] = Dynamo_Regions.getAllPhoneCodes();
-  static ISOs: CountryISO[] = Dynamo_Regions.getAllCountryISO();
+  static divisions: Dynamo_CountryDivision[] = Dynamo_Regions.getAllDivisions();
+  static phoneCodes: Dynamo_CountryPhoneCode[] = Dynamo_Regions.getAllPhoneCodes();
+  static ISOs: Dynamo_CountryISO[] = Dynamo_Regions.getAllCountryISO();
 
-  private static getAllDivisions(): CountryDivision[] {
-    return JSONListify(Divisions);
+  private static getAllDivisions(): Dynamo_CountryDivision[] {
+    return Dynamo_JSONListify(Divisions);
   }
-  private static getAllPhoneCodes(): CountryPhoneCode[] {
-    return JSONListify(PhoneCodes);
+  private static getAllPhoneCodes(): Dynamo_CountryPhoneCode[] {
+    return Dynamo_JSONListify(PhoneCodes);
   }
 
   /*  private static getSubdivisionCollection(): DivisionCollection {
     return Divisions as DivisionCollection;
   } */
-  private static getAllCountryISO(): CountryISO[] {
-    const result: CountryISO[] = JSONListify(ISOs);
+  private static getAllCountryISO(): Dynamo_CountryISO[] {
+    const result: Dynamo_CountryISO[] = Dynamo_JSONListify(ISOs);
 
-    result.forEach((iso: CountryISO): void => {
+    result.forEach((iso: Dynamo_CountryISO): void => {
       iso.phoneCode = this.phoneCodes.find(
-        (pc: CountryPhoneCode): boolean => pc.iso === iso.iso2
+        (pc: Dynamo_CountryPhoneCode): boolean => pc.iso === iso.iso2
       )?.code;
-      iso.divisions = this.divisions.filter((d: CountryDivision): boolean => d.iso === iso.iso2);
+      iso.divisions = this.divisions.filter((d: Dynamo_CountryDivision): boolean => d.iso === iso.iso2);
     });
 
     return result;
   }
 
-  static isoToCountryIso(iso2: string): CountryISO {
-    const country: CountryISO = this.ISOs.find((iso: CountryISO): boolean => iso.iso2 == iso2);
+  static isoToCountryIso(iso2: string): Dynamo_CountryISO {
+    const country: Dynamo_CountryISO = this.ISOs.find((iso: Dynamo_CountryISO): boolean => iso.iso2 == iso2);
 
     if (!country) {
       throw new Dynamo_Error({ 
@@ -56,7 +56,7 @@ export class Dynamo_Regions {
 
   static isoToRegion(iso2: string): Dynamo_Region {
     const region: Dynamo_Region = this.ISOs.find(
-      (iso: CountryISO): boolean => iso.iso2 == iso2
+      (iso: Dynamo_CountryISO): boolean => iso.iso2 == iso2
     )?.region;
 
     if (!region) {
@@ -68,9 +68,9 @@ export class Dynamo_Regions {
     }
   }
 
-  static isoToPhoneCode(iso2: string): CountryPhoneCode {
-    const phoneCode: CountryPhoneCode = this.phoneCodes.find(
-      (code: CountryPhoneCode): boolean => code.iso == iso2
+  static isoToPhoneCode(iso2: string): Dynamo_CountryPhoneCode {
+    const phoneCode: Dynamo_CountryPhoneCode = this.phoneCodes.find(
+      (code: Dynamo_CountryPhoneCode): boolean => code.iso == iso2
     );
 
     if (!phoneCode) {

package/src/_utils/shared.static-service.ts

@@ -1,5 +1,5 @@
 
-import { clone } from './utilities.util';
+import { Dynamo_clone } from './utilities.util';
 
 export type D_Shared = Dynamo_Shared;
 export class Dynamo_Shared {
@@ -55,7 +55,7 @@ export class Dynamo_Shared {
    * @returns data from object by path
    */
   static getNestedData(parentObj: object, nestedDataKeys: string[]): any {
-    let newData = clone(parentObj); // {...parentObj};
+    let newData = Dynamo_clone(parentObj); // {...parentObj};
 
     nestedDataKeys.forEach((dk: string): void => {
       if (newData) {
@@ -74,7 +74,7 @@ export class Dynamo_Shared {
    * @returns modified data
    */
   static nestData(parentObj: object, nestKeys: string[], dataToSet: any): object {
-    const newData = clone(parentObj); // {...parentObj};
+    const newData = Dynamo_clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
       const keys = [...nestKeys];
@@ -96,7 +96,7 @@ export class Dynamo_Shared {
    * @returns modified data
    */
   static addToNestedData(parentObj: object, nestKeys: string[], dataToAdd: any): object {
-    const newData = clone(parentObj); // {...parentObj};
+    const newData = Dynamo_clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
       const keys = [...nestKeys];
@@ -118,7 +118,7 @@ export class Dynamo_Shared {
    * @returns modified data
    */
   static pushToNestedData(parentObj: object, nestKeys: string[], dataToPush: any): object {
-    const newData = clone(parentObj); // {...parentObj};
+    const newData = Dynamo_clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
       const keys = [...nestKeys];
@@ -150,7 +150,7 @@ export class Dynamo_Shared {
     nestIndexes: number[], 
     dataToSet: any
   ): T {
-    const newData = clone(parentObj); // parentObj; // {...parentObj};
+    const newData = Dynamo_clone(parentObj); // parentObj; // {...parentObj};
 
     if (nestIndexes.length > 1) {
       const indexes = [...nestIndexes];

package/src/_utils/time.util.ts

@@ -1,5 +1,5 @@
 
-import { day, hour, month, week, year } from '../_constants/times.const';
+import { day, hour, minute, month, second, week, year } from '../_constants/times.const';
 import { Dynamo_Month } from '../_enums';
 import { Dynamo_DayOfWeek } from '../_enums/day-of-week.enum';
 import { Dynamo_RelativeDate } from '../_enums/relative-date.enum';
@@ -8,6 +8,14 @@ export type D_Time = Dynamo_Time;
 export type D_T = Dynamo_Time;
 export class Dynamo_Time {
 
+  static readonly second = second;
+  static readonly minute = minute;
+  static readonly hour = hour;
+  static readonly day = day;
+  static readonly week = week;
+  static readonly month = month;
+  static readonly year = year;
+
   static getAge(birthDate: Date | number | string): number {
     return this.getYear(+new Date() - +new Date(birthDate));
   }

package/src/_utils/utilities.util.ts

@@ -4,7 +4,7 @@ const defaultErrorMsg = ' failed. ' +
 'containes object hooks for its own objects, therefore its creating an object loop. ' +
 'See further information in the detailed error:\n\n';
 
-export function clone<T>(object: T): T {
+export function Dynamo_clone<T>(object: T): T {
   try {
     return object ? JSON.parse(JSON.stringify(object)) as T : object;
   } catch (error) {
@@ -16,9 +16,11 @@ export function clone<T>(object: T): T {
     throw error;
   }
 }
-export const copy = clone;
+export const Dynamo_copy = Dynamo_clone;
+export const D_clone = Dynamo_clone;
+export const D_copy = Dynamo_clone;
 
-export function surfaceClone<T>(object: T): T {
+export function Dynamo_surfaceClone<T>(object: T): T {
   try {
     const result = {};
 
@@ -36,9 +38,11 @@ export function surfaceClone<T>(object: T): T {
     throw error;
   }
 }
-export const surfaceCopy = surfaceClone;
+export const Dynamo_surfaceCopy = Dynamo_surfaceClone;
+export const D_surfaceClone = Dynamo_surfaceClone;
+export const D_surfaceCopy = Dynamo_surfaceClone;
 
-export function sameObjects<T>(objA: T, objB: T): boolean {
+export function Dynamo_sameObjects<T>(objA: T, objB: T): boolean {
   try {
     return JSON.stringify(objA) === JSON.stringify(objB);
   } catch (error) {
@@ -50,25 +54,30 @@ export function sameObjects<T>(objA: T, objB: T): boolean {
     throw error;
   }
 }
+export const D_sameObjects = Dynamo_sameObjects;
 
 /**
  * sets values if its existing on To, even if its null (but if undefined)
  * @param setOn
  * @param setTo 
  */
-export function setExisitngValuesOnly(setOn: any, setTo: any): void {
+export function Dynamo_setExisitngValuesOnly(setOn: any, setTo: any): void {
   for (const key in setTo) {
     if (setTo[key] != undefined) {
       setOn[key] = setTo[key];
     }
   }
 }
+export const D_setExisitngValuesOnly = Dynamo_setExisitngValuesOnly;
 
-export function delay(ms: number): Promise<void> {
+export function Dynamo_delay(ms: number): Promise<void> {
   return new Promise((resolve): any => setTimeout(resolve, ms));
 }
-export const sleep = delay;
-export const wait = delay;
+export const Dynamo_sleep = Dynamo_delay;
+export const Dynamo_wait = Dynamo_delay;
+export const D_delay = Dynamo_delay;
+export const D_sleep = Dynamo_delay;
+export const D_wait = Dynamo_delay;
 
 export type Dynamo_SortDirection = 0 | 1 | -1
 
@@ -83,11 +92,12 @@ export type Dynamo_SortDirection = 0 | 1 | -1
  * @example 
  * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
  */
-export function sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): Dynamo_SortDirection {
+export function Dynamo_sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): Dynamo_SortDirection {
   const isA = check(a);
 
   return isA === check(b) ? 0 : isA ? -1 : 1;
 }
+export const D_sortForTrue = Dynamo_sortForTrue;
 
 /**
  * 
@@ -97,12 +107,13 @@ export function sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): Dynamo_Sor
  * @example
  * codes.sort(getSortForTrueFn((c: Code) => c.haveImg));
  */
-export function getSortForTrueFn<T>(
+export function Dynamo_getSortForTrueFn<T>(
   checkFor: (a: T) => boolean): (a: T, b: T) => Dynamo_SortDirection {
-  return (a: T, b: T): Dynamo_SortDirection => sortForTrue<T>(a, b, checkFor);
+  return (a: T, b: T): Dynamo_SortDirection => Dynamo_sortForTrue<T>(a, b, checkFor);
 }
+export const D_getSortForTrueFn = Dynamo_getSortForTrueFn;
 
-export function JSONListify<T>(JSONList): T[] {
+export function Dynamo_JSONListify<T>(JSONList): T[] {
   const result: T[] = [];
 
   for (let i = 0; JSONList[i]; i++) {
@@ -111,4 +122,5 @@ export function JSONListify<T>(JSONList): T[] {
 
   return result; 
 }
+export const D_JSONListify = Dynamo_JSONListify;