@futdevpro/fsm-dynamo 1.20.8 → 1.20.10

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

@@ -1,481 +0,0 @@
-
-import { day, hour, minute, month, second, week, year } from '../constants/times.const';
-import { DyFM_Month } from '../../_enums/time/month.enum';
-import { DyFM_DayOfWeek } from '../../_enums/time/day-of-week.enum';
-import { DyFM_RelativeDate } from '../../_enums/time/relative-date.enum';
-import { DyFM_Math } from './math/math.util';
-
-/* export type DyFM_T = DyFM_Time; */
-/**
- * Time utility class
- */
-export class DyFM_Time {
-
-  /**
-   * The number of milliseconds in a second
-   */
-  static readonly second = second;
-
-  /**
-   * The number of milliseconds in a minute
-   */
-  static readonly minute = minute;
-
-  /**
-   * The number of milliseconds in an hour
-   */
-  static readonly hour = hour;
-  
-  /**
-   * The number of milliseconds in a day
-   */
-  static readonly day = day;
-
-  /**
-   * The number of milliseconds in a week
-   */
-  static readonly week = week;
-
-  /**
-   * The number of milliseconds in a month
-   */
-  static readonly month = month;
-
-  /**
-   * The number of milliseconds in a year
-   */
-  static readonly year = year;
-
-  /**
-   * Get the age of a person
-   * @param birthDate - The birth date of the person
-   * @returns The age of the person
-   * 
-   * @example
-   * ```ts
-   * const birthDate = new Date('1990-01-01');
-   * const age = DyFM_Time.getAge(birthDate);
-   * console.log(age); // 31
-   * ```
-   */
-  static getAge(birthDate: Date | number | string): number {
-    return this.getYear(+new Date() - +new Date(birthDate));
-  }
-
-  /**
-   * returns the date as a number of years
-   * @param date 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const date = new Date('2025-01-01');
-   * const year = DyFM_Time.getYear(date);
-   * console.log(year); // 2025
-   * ```
-   */
-  static getYear(date: Date | number | string): number {
-    if (typeof date === 'string') {
-      date = new Date(date);
-    }
-    
-    return (+date  / year);
-  }
-
-  /**
-   * returns the date as a number of hours
-   * @param date 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const date = new Date('2025-01-01');
-   * const hour = DyFM_Time.getHour(date);
-   * console.log(hour); // 1
-   * ```
-   */
-  static getHour(date: Date | number | string): number {
-    if (typeof date === 'string') {
-      date = new Date(date);
-    }
-
-    return (+date  / hour);
-  }
-
-  /**
-   * calculates the birthdate from the age 
-   * (with current date so this wont be accurate for days or months, only years)
-   * @param date 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const age = 31;
-   * const date = DyFM_Time.getDateByAge(age);
-   * console.log(date); // 1990-01-01
-   * ```
-   */
-  static getDateByAge(age: number): Date {
-    return new Date(+new Date() - (year * age));
-  }
-
-  /**
-   * returns the date x before the current date
-   * @param relativeDate 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const date = DyFM_Time.getDateByRelativeDate(DyFM_RelativeDate.lastDay);
-   * ```
-   */
-  static getDateByRelativeDate(
-    relativeDate: DyFM_RelativeDate, 
-    comparedTo?: Date
-  ): Date {
-    switch (relativeDate) {
-      case DyFM_RelativeDate.lastDay:
-        return this.oneDayAgo(comparedTo);
-
-      case DyFM_RelativeDate.lastWeek:
-        return this.oneWeekAgo(comparedTo);
-
-      case DyFM_RelativeDate.lastMonth:
-        return this.oneMonthAgo(comparedTo);
-
-      case DyFM_RelativeDate.lastYear:
-        return this.oneYearAgo(comparedTo);
-
-      case DyFM_RelativeDate.last10Years:
-        return this.tenYearsAgo(comparedTo);
-
-      case DyFM_RelativeDate.allTime:
-        return new Date(0);
-
-      default:
-        return new Date(0);
-    }
-  }
-
-  /**
-   * returns the date one hour ago
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const comparedTo = new Date('2025-01-01');
-   * const date = DyFM_Time.oneHourAgo(comparedTo);
-   * console.log(date); // 2024-12-31 23:00:00
-   * ```
-   */
-  static oneHourAgo(comparedTo: Date = new Date()): Date {
-    return new Date(+comparedTo - hour);
-  }
-
-  /**
-   * returns the date one day ago
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const comparedTo = new Date('2025-01-01');
-   * const date = DyFM_Time.oneDayAgo(comparedTo);
-   * console.log(date); // 2024-12-31
-   * ```
-   */
-  static oneDayAgo(comparedTo: Date = new Date()): Date {
-    return new Date(+comparedTo - day);
-  }
-
-  /**
-   * returns the date one week ago
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const comparedTo = new Date('2025-01-01');
-   * const date = DyFM_Time.oneWeekAgo(comparedTo);
-   * console.log(date); // 2024-12-25
-   * ```
-   */
-  static oneWeekAgo(comparedTo: Date = new Date()): Date {
-    return new Date(+comparedTo - week);
-  }
-
-  /**
-   * returns the date one month ago
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const comparedTo = new Date('2025-01-01');
-   * const date = DyFM_Time.oneMonthAgo(comparedTo);
-   * console.log(date); // 2024-12-01
-   * ```
-   */
-  static oneMonthAgo(comparedTo: Date = new Date()): Date {
-    return new Date(+comparedTo - month);
-  }
-  
-  /**
-   * returns the date one year ago
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const comparedTo = new Date('2025-01-01');
-   * const date = DyFM_Time.oneYearAgo(comparedTo);
-   * console.log(date); // 2024-01-01
-   * ```
-   */
-  static oneYearAgo(comparedTo: Date = new Date()): Date {
-    return new Date(+comparedTo - year);
-  }
-  
-  /**
-   * returns the date ten years ago
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const comparedTo = new Date('2025-01-01');
-   * const date = DyFM_Time.tenYearsAgo(comparedTo);
-   * console.log(date); // 2015-01-01
-   * ```
-   */
-  static tenYearsAgo(comparedTo: Date = new Date()): Date {
-    return new Date(+comparedTo - (10 * year));
-  }
-
-  /**
-   * returns the DyFM_DayOfWeek type of the current day
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const today = DyFM_Time.getTodayOfWeek();
-   * console.log(today); // DyFM_DayOfWeek.monday
-   * ```
-   */
-  static getTodayOfWeek(): DyFM_DayOfWeek {
-    return DyFM_DayOfWeek[
-      new Date().toLocaleString('en-us', { weekday: 'long' }).toLocaleLowerCase() as keyof typeof DyFM_DayOfWeek
-    ];
-  }
-
-  /**
-   * returns the days of the week from today to the end of the week in DyFM_DayOfWeek format
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const daysOfWeek = DyFM_Time.getDaysOfWeekFromToday();
-   * console.log(daysOfWeek); // [ DyFM_DayOfWeek.monday, DyFM_DayOfWeek.tuesday, DyFM_DayOfWeek.wednesday, DyFM_DayOfWeek.thursday, DyFM_DayOfWeek.friday, DyFM_DayOfWeek.saturday, DyFM_DayOfWeek.sunday ]
-   * ```
-   */
-  static getDaysOfWeekFromToday(): DyFM_DayOfWeek[] {
-    const today: DyFM_DayOfWeek = this.getTodayOfWeek();
-    const daysOfWeek: DyFM_DayOfWeek[] = Object.values(DyFM_DayOfWeek);
-    const todayIndex: number = daysOfWeek.indexOf(today);
-
-    return daysOfWeek.slice(todayIndex).concat(daysOfWeek.slice(0, todayIndex));
-  }
-
-  /**
-   * returns the days of the week to today to the end of the week in DyFM_DayOfWeek format
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const daysOfWeek = DyFM_Time.getDaysOfWeekToToday();
-   * console.log(daysOfWeek); // [ DyFM_DayOfWeek.sunday, DyFM_DayOfWeek.saturday, DyFM_DayOfWeek.friday, DyFM_DayOfWeek.thursday, DyFM_DayOfWeek.wednesday, DyFM_DayOfWeek.tuesday, DyFM_DayOfWeek.monday ]
-   * ```
-   */
-  static getDaysOfWeekToToday(): DyFM_DayOfWeek[] {
-    const today: DyFM_DayOfWeek = this.getTodayOfWeek();
-    const daysOfWeek: DyFM_DayOfWeek[] = Object.values(DyFM_DayOfWeek);
-    const todayIndex: number = daysOfWeek.indexOf(today);
-
-    return daysOfWeek.slice(0, todayIndex).reverse().concat(daysOfWeek.slice(todayIndex).reverse());
-  }
-
-  /**
-   * returns the DyFM_Month type of the current month
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const month = DyFM_Time.getCurrentMonth();
-   * console.log(month); // DyFM_Month.january
-   * ```
-   */
-  static getCurrentMonth(): DyFM_Month {
-    return DyFM_Month[
-      new Date().toLocaleString('en-us', { month: 'long' }).toLocaleLowerCase() as keyof typeof DyFM_Month
-    ];
-  }
-
-  /**
-   * returns the number of days in the month
-   * @param inYear this value is important for february if you want to know if it is a leap year
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const monthLength = DyFM_Time.getMonthLength(DyFM_Month.january);
-   * console.log(monthLength); // 31
-   * ```
-   */
-  static getMonthLength(month: DyFM_Month, inYear?: number): number {
-    switch (month) {
-      case DyFM_Month.january:
-      case DyFM_Month.march:
-      case DyFM_Month.may:
-      case DyFM_Month.june:
-      case DyFM_Month.august:
-      case DyFM_Month.october:
-        return 31;
-
-      case DyFM_Month.april:
-      case DyFM_Month.july:
-      case DyFM_Month.september:
-      case DyFM_Month.november:
-      case DyFM_Month.december:
-        return 30;
-
-      case DyFM_Month.february:
-        return this.isLeapYear(inYear ?? new Date().getFullYear()) ? 29 : 28;
-    }
-  }
-
-  /**
-   * returns year is leap or not
-   * @param year 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const isLeapYear = DyFM_Time.isLeapYear(2024);
-   * console.log(isLeapYear); // true
-   * ```
-   */
-  static isLeapYear(year: number): boolean {
-    return year % 4 === 0;
-  }
-
-  /**
-   * returns the duration string
-   * @param duration 
-   * @param full 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const duration = 1000;
-   * const durationString = DyFM_Time.getDurationString(duration);
-   * console.log(durationString); // 1s
-   * ```
-   */
-  static getDurationString(duration: number, full?: boolean): string {
-    // Ha 0ms az idő, akkor rögtön visszaadjuk
-    if (duration === 0) {
-      return '0ms';
-    }
-
-    if (!duration) {
-      return 'N/A';
-    }
-
-    // Nagyon rövid idő: < 100ms → ms-ben mutatjuk
-    if (duration < (second / 10)) {
-      return `${duration}ms`;
-    }
-
-    // < 1s → másodperc két tizedesjeggyel (jobb olvashatóság)
-    if (duration < second) {
-      return `${DyFM_Math.round(duration / second, 2)}s`;
-    }
-
-    // < 1m → csak másodperc (és opcionálisan ms, ha full=true)
-    if (duration < minute) {
-      const secondsWhole: number = DyFM_Math.round(duration / second, 0);
-      if (full) {
-        const remainingMs: number = duration % second;
-        return `${secondsWhole}s ${remainingMs}ms`;
-      }
-      return `${secondsWhole}s`;
-    }
-
-    // < 1h → perc + másodperc (helyes egység-átváltással)
-    if (duration < hour) {
-      const minutesWhole: number = DyFM_Math.round(duration / minute, 0);
-      const remainingSeconds: number = DyFM_Math.round((duration % minute) / second, 0);
-      return `${minutesWhole}m ${remainingSeconds}s`;
-    }
-
-    // < 1d → óra + perc
-    if (duration < day) {
-      const hoursWhole: number = DyFM_Math.round(duration / hour, 0);
-      const remainingMinutes: number = DyFM_Math.round((duration % hour) / minute, 0);
-      return `${hoursWhole}h ${remainingMinutes}m`;
-    }
-
-    // < 1w → nap + óra
-    if (duration < week) {
-      const daysWhole: number = DyFM_Math.round(duration / day, 0);
-      const remainingHours: number = DyFM_Math.round((duration % day) / hour, 0);
-      return `${daysWhole}d ${remainingHours}h`;
-    }
-
-    // < 1 month → hét + nap
-    if (duration < month) {
-      const weeksWhole: number = DyFM_Math.round(duration / week, 0);
-      const remainingDays: number = DyFM_Math.round((duration % week) / day, 0);
-      return `${weeksWhole}w ${remainingDays}d`;
-    }
-
-    // < 1y → month + hét
-    if (duration < year) {
-      const monthsWhole: number = DyFM_Math.round(duration / month, 0);
-      const remainingWeeks: number = DyFM_Math.round((duration % month) / week, 0);
-      return `${monthsWhole}m ${remainingWeeks}w`;
-    }
-
-    // ≥ 1y → év + hónap
-    const yearsWhole: number = DyFM_Math.round(duration / year, 0);
-    const remainingMonths: number = DyFM_Math.round((duration % year) / month, 0);
-    return `${yearsWhole}y ${remainingMonths}m`;
-  }
-
-  /**
-   * returns the time in the shortest string
-   * @param time 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const time = 345;
-   * const timeString = DyFM_Time.getTimeInShortestString(time);
-   * console.log(timeString); // 345ms
-   * ```
-   */
-  static getTimeInShortestString(time: number): string {
-    if (time % year === 0) {
-      return `${time / year}y`;
-    } else if (time % month === 0) {
-      return `${time / month}m`;
-    } else if (time % week === 0) {
-      return `${time / week}w`;
-    } else if (time % day === 0) {
-      return `${time / day}d`;
-    } else if (time % hour === 0) {
-      return `${time / hour}h`;
-    } else if (time % minute === 0) {
-      return `${time / minute}m`;
-    } else if (time % second === 0) {
-      return `${time / second}s`;
-    } else {
-      return `${time}ms`;
-    }
-  }
-}

package/src/_collections/utils/type-cloning-facility.util.spec.ts

@@ -1,51 +0,0 @@
-
-import { DyFM_TypeCloningFacility } from './type-cloning-facility.util';
-
-describe('| DyFM_TypeCloningFacility', () => {
-
-  it('| should clone a simple object', () => {
-    const original = { a: 1, b: 'test', c: true };
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned).not.toBe(original);
-  });
-
-  it('| should clone an object with nested objects', () => {
-    const original = { a: { b: { c: 2 } } };
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned).not.toBe(original);
-    expect(cloned.a).not.toBe(original.a);
-    expect(cloned.a.b).not.toBe(original.a.b);
-  });
-
-  xit('should handle circular references', () => {
-    const original: any = { a: 1 };
-    original.self = original;
-
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual({ a: 1, self: cloned });
-    expect(cloned).not.toBe(original);
-  });
-
-  it('| should clone arrays within objects', () => {
-    const original = { a: [1, 2, 3] };
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned.a).not.toBe(original.a);
-  });
-
-  it('| should clone an array of objects', () => {
-    const original = [{ a: 1 }, { b: 2 }];
-    const cloned = DyFM_TypeCloningFacility.cloneArray(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned).not.toBe(original);
-    expect(cloned[0]).not.toBe(original[0]);
-    expect(cloned[1]).not.toBe(original[1]);
-  });
-});

package/src/_collections/utils/type-cloning-facility.util.ts

@@ -1,168 +0,0 @@
-export type DyFM_TCF = DyFM_TypeCloningFacility;
-
-/** 
- * 
- * This functions should be able to clone any object, 
- * even if it contains circular references.
- * 
- * if the object has a clone() function, it will be used.
- * if the object has any getter or setter, it will be ignored, 
- * therefore it should have a clone() function.
- * 
- * WARNING: this function will clone all connected objects!
- * 
- * */
-export class DyFM_TypeCloningFacility {
-
-  /**
-   * Clone an object
-   * @param object - The object to clone
-   * @param skip - An array of keys to skip
-   * @param affectedObjects - An array of objects that have already been cloned
-   * @param debug - Whether to log debug information
-   * @returns The cloned object
-   */
-  static clone<T>(
-    object: T, 
-    skip: string[] = [], 
-    affectedObjects: ObjectCollector[] = [],
-    debug: boolean = false
-  ): T {
-    const result: T = {} as T;
-
-    for (const key in object) {
-      if (debug) {
-        console.log('clone DEBUG; key:', key);
-      }
-
-      if (object && typeof object === 'object'/* object.hasOwnProperty(key) */) {
-        const type: string = typeof object[key];
-
-        if (skip.includes(key)) {
-          continue;
-
-        } else if (type === 'object') {
-          const alreadyAffected = affectedObjects?.find(
-            (affectedObject): boolean => affectedObject.id === object[key]
-          );
-
-          if (alreadyAffected) {
-            result[key] = alreadyAffected.clonedObject;
-            
-          } else {
-            const newAffectedObject: ObjectCollector = {
-              id: object[key] as string
-            };
-
-            affectedObjects.push(newAffectedObject);
-            
-            if (Array.isArray(object[key])) {
-              newAffectedObject.clonedObject = this.cloneArray(
-                object[key] as unknown[], 
-                skip, 
-                affectedObjects,
-                debug
-              );
-
-            } else if (
-              (object[key] as any)?.clone && 
-              typeof (object[key] as any)?.clone === 'function'
-            ) {
-              newAffectedObject.clonedObject = (object[key] as any).clone();
-
-            } else {
-              newAffectedObject.clonedObject = this.clone(
-                object[key], 
-                skip, 
-                affectedObjects,
-                debug
-              );
-            }
-
-            result[key] = newAffectedObject.clonedObject;
-          }
-        } else {
-          result[key] = object[key];
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Clone an array
-   * @param array - The array to clone
-   * @param skip - An array of keys to skip
-   * @param affectedObjects - An array of objects that have already been cloned
-   * @param debug - Whether to log debug information
-   * @returns The cloned array
-   */
-  static cloneArray<T>(
-    array: T[],
-    skip: string[] = [], 
-    affectedObjects: ObjectCollector[] = [],
-    debug: boolean = false
-  ): T[] {
-    const result: T[] = [];
-
-    array.forEach((element, index): void => {
-      if (debug) {
-        console.log('cloneArrayDEBUG; index', index);
-      }
-
-      if (typeof element === 'object') {
-        result.push(this.clone(element, skip, affectedObjects, debug));
-
-      } else {
-        result.push(element);
-      }
-    });
-
-    return result;
-  }
-
-  /**
-   * Store the circulation of an object
-   * @param object - The object to store the circulation of
-   * @returns The serialized object
-   */
-  static storeCirculation(object: any): string {
-    const cache = new Map();
-    const result = JSON.stringify(object, (key, value) => {
-      if (typeof value === 'object' && value !== null) {
-        if (cache.has(value)) {
-          return `__cycle__${cache.get(value)}`;
-        }
-        cache.set(value, cache.size);
-      }
-      return value;
-    });
-    return result;
-  }
-
-  /**
-   * Restore the circulation of an object
-   * @param serialized - The serialized object
-   * @returns The restored object
-   */
-  static restoreCirculation(serialized: string): any {
-    const cache = new Map();
-    const result = JSON.parse(serialized, (key, value) => {
-      if (typeof value === 'string' && value.startsWith('__cycle__')) {
-        return cache.get(parseInt(value.slice(9), 10));
-      }
-      if (typeof value === 'object' && value !== null) {
-        cache.set(cache.size, value);
-      }
-      return value;
-    });
-    return result;
-  }
-}
-
-interface ObjectCollector {
-  id: string;
-  clonedObject?: any;
-}
-