@futdevpro/fsm-dynamo 1.20.88 → 1.20.93

package/build-esm/_collections/utils/time.util.js

@@ -0,0 +1,431 @@
+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 second = second;
+    /**
+     * The number of milliseconds in a minute
+     */
+    static minute = minute;
+    /**
+     * The number of milliseconds in an hour
+     */
+    static hour = hour;
+    /**
+     * The number of milliseconds in a day
+     */
+    static day = day;
+    /**
+     * The number of milliseconds in a week
+     */
+    static week = week;
+    /**
+     * The number of milliseconds in a month
+     */
+    static month = month;
+    /**
+     * The number of milliseconds in a year
+     */
+    static 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) {
+        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) {
+        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) {
+        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) {
+        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, comparedTo) {
+        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 = new 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 = new 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 = new 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 = new 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 = new 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 = new 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() {
+        return DyFM_DayOfWeek[new Date().toLocaleString('en-us', { weekday: 'long' }).toLocaleLowerCase()];
+    }
+    /**
+     * 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() {
+        const today = this.getTodayOfWeek();
+        const daysOfWeek = Object.values(DyFM_DayOfWeek);
+        const todayIndex = 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() {
+        const today = this.getTodayOfWeek();
+        const daysOfWeek = Object.values(DyFM_DayOfWeek);
+        const todayIndex = 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() {
+        return DyFM_Month[new Date().toLocaleString('en-us', { month: 'long' }).toLocaleLowerCase()];
+    }
+    /**
+     * 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, inYear) {
+        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) {
+        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, full) {
+        // 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 = DyFM_Math.round(duration / second, 0);
+            if (full) {
+                const remainingMs = 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 = DyFM_Math.round(duration / minute, 0);
+            const remainingSeconds = DyFM_Math.round((duration % minute) / second, 0);
+            return `${minutesWhole}m ${remainingSeconds}s`;
+        }
+        // < 1d → óra + perc
+        if (duration < day) {
+            const hoursWhole = DyFM_Math.round(duration / hour, 0);
+            const remainingMinutes = DyFM_Math.round((duration % hour) / minute, 0);
+            return `${hoursWhole}h ${remainingMinutes}m`;
+        }
+        // < 1w → nap + óra
+        if (duration < week) {
+            const daysWhole = DyFM_Math.round(duration / day, 0);
+            const remainingHours = DyFM_Math.round((duration % day) / hour, 0);
+            return `${daysWhole}d ${remainingHours}h`;
+        }
+        // < 1 month → hét + nap
+        if (duration < month) {
+            const weeksWhole = DyFM_Math.round(duration / week, 0);
+            const remainingDays = DyFM_Math.round((duration % week) / day, 0);
+            return `${weeksWhole}w ${remainingDays}d`;
+        }
+        // < 1y → month + hét
+        if (duration < year) {
+            const monthsWhole = DyFM_Math.round(duration / month, 0);
+            const remainingWeeks = DyFM_Math.round((duration % month) / week, 0);
+            return `${monthsWhole}m ${remainingWeeks}w`;
+        }
+        // ≥ 1y → év + hónap
+        const yearsWhole = DyFM_Math.round(duration / year, 0);
+        const remainingMonths = 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) {
+        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/build-esm/_collections/utils/type-cloning-facility.util.js

@@ -0,0 +1,122 @@
+/**
+ *
+ * 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(object, skip = [], affectedObjects = [], debug = false) {
+        const result = {};
+        for (const key in object) {
+            if (debug) {
+                console.log('clone DEBUG; key:', key);
+            }
+            if (object && typeof object === 'object' /* object.hasOwnProperty(key) */) {
+                const type = typeof object[key];
+                if (skip.includes(key)) {
+                    continue;
+                }
+                else if (type === 'object') {
+                    const alreadyAffected = affectedObjects?.find((affectedObject) => affectedObject.id === object[key]);
+                    if (alreadyAffected) {
+                        result[key] = alreadyAffected.clonedObject;
+                    }
+                    else {
+                        const newAffectedObject = {
+                            id: object[key]
+                        };
+                        affectedObjects.push(newAffectedObject);
+                        if (Array.isArray(object[key])) {
+                            newAffectedObject.clonedObject = this.cloneArray(object[key], skip, affectedObjects, debug);
+                        }
+                        else if (object[key]?.clone &&
+                            typeof object[key]?.clone === 'function') {
+                            newAffectedObject.clonedObject = object[key].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(array, skip = [], affectedObjects = [], debug = false) {
+        const result = [];
+        array.forEach((element, index) => {
+            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) {
+        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) {
+        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;
+    }
+}

package/build-esm/_collections/utils/utilities.util.js

@@ -0,0 +1,61 @@
+import { DyFM_BasicProperty_Type } from '../../_enums/basic-property-type.enum';
+/**
+ * checks if the value is not null or undefined
+ * @param value - The value to check
+ * @returns True if the value is not null or undefined, false otherwise
+ *
+ * @example
+ * ```ts
+ * const value = 'test';
+ * const result = DyFM_notNull(value);
+ * console.log(result); // true
+ */
+export function DyFM_notNull(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * get the basic property type of the value
+ * @param type - The type to check
+ * @returns The basic property type of the value
+ *
+ * @example
+ * ```ts
+ * const type = 'string';
+ * const result = DyFM_getBasicPropertyType(type);
+ * console.log(result); // DyFM_BasicProperty_Type.string
+ */
+export function DyFM_getBasicPropertyType(type) {
+    if (!type) {
+        throw new Error('Type is missing');
+    }
+    switch (type.toLocaleLowerCase()) {
+        case DyFM_BasicProperty_Type.string:
+        case 'string':
+            return DyFM_BasicProperty_Type.string;
+        case DyFM_BasicProperty_Type.number:
+        case 'number':
+            return DyFM_BasicProperty_Type.number;
+        case DyFM_BasicProperty_Type.boolean:
+        case 'boolean':
+            return DyFM_BasicProperty_Type.boolean;
+        case DyFM_BasicProperty_Type.date:
+        case 'date':
+            return DyFM_BasicProperty_Type.date;
+        case DyFM_BasicProperty_Type.object:
+        case 'object':
+            return DyFM_BasicProperty_Type.object;
+        case DyFM_BasicProperty_Type.array:
+        case 'array':
+            return DyFM_BasicProperty_Type.array;
+        default:
+            if (type.includes('[]') || type.includes('array')) {
+                return DyFM_BasicProperty_Type.array;
+            }
+            else if (type.includes('=>') || type.includes('function')) {
+                return DyFM_BasicProperty_Type.function;
+            }
+            else {
+                return DyFM_BasicProperty_Type.object;
+            }
+    }
+}

package/build-esm/_collections/utils/uuid.util.js

@@ -0,0 +1,33 @@
+/* let UUID: any;
+
+try {
+  UUID = import('uuid');
+} catch {
+  console.log(
+    '❌ uuid package not found, please install it with: pnpm add uuid'
+  );
+} */
+import * as UUID from 'uuid';
+export class DyFM_UUID {
+    /* static readonly getUUID = UUID.v4; */
+    /**
+     * generates a UUID
+     * @param reserved - an array of reserved UUIDs
+     * @returns a UUID
+     *
+     * @example
+     * ```ts
+     * const uuid = DyFM_UUID.generate();
+     * console.log(uuid); // 123e4567-e89b-12d3-a456-426614174000
+     * ```
+     */
+    static generate(reserved) {
+        let uuid = UUID.v4();
+        if (reserved) {
+            while (reserved.includes(uuid)) {
+                uuid = UUID.v4();
+            }
+        }
+        return uuid;
+    }
+}

package/build-esm/_enums/basic-property-type.enum.js

@@ -0,0 +1,18 @@
+/**
+ * Basic property types used by the framework.
+ *
+ * @example
+ * ```ts
+ * const type: DyFM_BasicProperty_Type = DyFM_BasicProperty_Type.string;
+ * ```
+ */
+export var DyFM_BasicProperty_Type;
+(function (DyFM_BasicProperty_Type) {
+    DyFM_BasicProperty_Type["string"] = "string";
+    DyFM_BasicProperty_Type["number"] = "number";
+    DyFM_BasicProperty_Type["boolean"] = "boolean";
+    DyFM_BasicProperty_Type["date"] = "date";
+    DyFM_BasicProperty_Type["object"] = "object";
+    DyFM_BasicProperty_Type["array"] = "array";
+    DyFM_BasicProperty_Type["function"] = "function";
+})(DyFM_BasicProperty_Type || (DyFM_BasicProperty_Type = {}));

package/build-esm/_enums/data-model-type.enum.js

@@ -0,0 +1,24 @@
+/**
+ * Indicates in which layer a given structure is used based on its model type.
+ *
+ * @example
+ * ```ts
+ * const type = DyFM_DataModel_Type.data;
+ * ```
+ */
+export var DyFM_DataModel_Type;
+(function (DyFM_DataModel_Type) {
+    DyFM_DataModel_Type["data"] = "data-model";
+    DyFM_DataModel_Type["control"] = "control-model";
+    DyFM_DataModel_Type["interface"] = "interface";
+})(DyFM_DataModel_Type || (DyFM_DataModel_Type = {}));
+/**
+ * Array containing every available data model type.
+ *
+ * @example
+ * ```ts
+ * const dataModelTypes = DyFM_allDataModelTypes;
+ * console.log(dataModelTypes); // [ DyFM_DataModel_Type.data, DyFM_DataModel_Type.control, DyFM_DataModel_Type.interface ]
+ * ```
+ */
+export const DyFM_allDataModelTypes = Object.values(DyFM_DataModel_Type);