@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_collections/utils/type-cloning-facility.util.d.ts

@@ -1,51 +1,51 @@
-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 declare 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): T;
-    /**
-     * 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): T[];
-    /**
-     * Store the circulation of an object
-     * @param object - The object to store the circulation of
-     * @returns The serialized object
-     */
-    static storeCirculation(object: any): string;
-    /**
-     * Restore the circulation of an object
-     * @param serialized - The serialized object
-     * @returns The restored object
-     */
-    static restoreCirculation(serialized: string): any;
-}
-interface ObjectCollector {
-    id: string;
-    clonedObject?: any;
-}
-export {};
+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 declare 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): T;
+    /**
+     * 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): T[];
+    /**
+     * Store the circulation of an object
+     * @param object - The object to store the circulation of
+     * @returns The serialized object
+     */
+    static storeCirculation(object: any): string;
+    /**
+     * Restore the circulation of an object
+     * @param serialized - The serialized object
+     * @returns The restored object
+     */
+    static restoreCirculation(serialized: string): any;
+}
+interface ObjectCollector {
+    id: string;
+    clonedObject?: any;
+}
+export {};
 //# sourceMappingURL=type-cloning-facility.util.d.ts.map

package/build/_collections/utils/type-cloning-facility.util.js

@@ -1,127 +1,127 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_TypeCloningFacility = void 0;
-/**
- *
- * 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!
- *
- * */
-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;
-    }
-}
-exports.DyFM_TypeCloningFacility = DyFM_TypeCloningFacility;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_TypeCloningFacility = void 0;
+/**
+ *
+ * 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!
+ *
+ * */
+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;
+    }
+}
+exports.DyFM_TypeCloningFacility = DyFM_TypeCloningFacility;
 //# sourceMappingURL=type-cloning-facility.util.js.map

package/build/_collections/utils/utilities.util.d.ts

@@ -1,26 +1,26 @@
-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 declare function DyFM_notNull(value: any): boolean;
-/**
- * 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 declare function DyFM_getBasicPropertyType(type: string): DyFM_BasicProperty_Type;
+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 declare function DyFM_notNull(value: any): boolean;
+/**
+ * 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 declare function DyFM_getBasicPropertyType(type: string): DyFM_BasicProperty_Type;
 //# sourceMappingURL=utilities.util.d.ts.map

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

@@ -1,66 +1,66 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_notNull = DyFM_notNull;
-exports.DyFM_getBasicPropertyType = DyFM_getBasicPropertyType;
-const basic_property_type_enum_1 = require("../../_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
- */
-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
- */
-function DyFM_getBasicPropertyType(type) {
-    if (!type) {
-        throw new Error('Type is missing');
-    }
-    switch (type.toLocaleLowerCase()) {
-        case basic_property_type_enum_1.DyFM_BasicProperty_Type.string:
-        case 'string':
-            return basic_property_type_enum_1.DyFM_BasicProperty_Type.string;
-        case basic_property_type_enum_1.DyFM_BasicProperty_Type.number:
-        case 'number':
-            return basic_property_type_enum_1.DyFM_BasicProperty_Type.number;
-        case basic_property_type_enum_1.DyFM_BasicProperty_Type.boolean:
-        case 'boolean':
-            return basic_property_type_enum_1.DyFM_BasicProperty_Type.boolean;
-        case basic_property_type_enum_1.DyFM_BasicProperty_Type.date:
-        case 'date':
-            return basic_property_type_enum_1.DyFM_BasicProperty_Type.date;
-        case basic_property_type_enum_1.DyFM_BasicProperty_Type.object:
-        case 'object':
-            return basic_property_type_enum_1.DyFM_BasicProperty_Type.object;
-        case basic_property_type_enum_1.DyFM_BasicProperty_Type.array:
-        case 'array':
-            return basic_property_type_enum_1.DyFM_BasicProperty_Type.array;
-        default:
-            if (type.includes('[]') || type.includes('array')) {
-                return basic_property_type_enum_1.DyFM_BasicProperty_Type.array;
-            }
-            else if (type.includes('=>') || type.includes('function')) {
-                return basic_property_type_enum_1.DyFM_BasicProperty_Type.function;
-            }
-            else {
-                return basic_property_type_enum_1.DyFM_BasicProperty_Type.object;
-            }
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_notNull = DyFM_notNull;
+exports.DyFM_getBasicPropertyType = DyFM_getBasicPropertyType;
+const basic_property_type_enum_1 = require("../../_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
+ */
+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
+ */
+function DyFM_getBasicPropertyType(type) {
+    if (!type) {
+        throw new Error('Type is missing');
+    }
+    switch (type.toLocaleLowerCase()) {
+        case basic_property_type_enum_1.DyFM_BasicProperty_Type.string:
+        case 'string':
+            return basic_property_type_enum_1.DyFM_BasicProperty_Type.string;
+        case basic_property_type_enum_1.DyFM_BasicProperty_Type.number:
+        case 'number':
+            return basic_property_type_enum_1.DyFM_BasicProperty_Type.number;
+        case basic_property_type_enum_1.DyFM_BasicProperty_Type.boolean:
+        case 'boolean':
+            return basic_property_type_enum_1.DyFM_BasicProperty_Type.boolean;
+        case basic_property_type_enum_1.DyFM_BasicProperty_Type.date:
+        case 'date':
+            return basic_property_type_enum_1.DyFM_BasicProperty_Type.date;
+        case basic_property_type_enum_1.DyFM_BasicProperty_Type.object:
+        case 'object':
+            return basic_property_type_enum_1.DyFM_BasicProperty_Type.object;
+        case basic_property_type_enum_1.DyFM_BasicProperty_Type.array:
+        case 'array':
+            return basic_property_type_enum_1.DyFM_BasicProperty_Type.array;
+        default:
+            if (type.includes('[]') || type.includes('array')) {
+                return basic_property_type_enum_1.DyFM_BasicProperty_Type.array;
+            }
+            else if (type.includes('=>') || type.includes('function')) {
+                return basic_property_type_enum_1.DyFM_BasicProperty_Type.function;
+            }
+            else {
+                return basic_property_type_enum_1.DyFM_BasicProperty_Type.object;
+            }
+    }
+}
 //# sourceMappingURL=utilities.util.js.map

package/build/_collections/utils/uuid.util.d.ts

@@ -1,15 +1,15 @@
-export declare class DyFM_UUID {
-    /**
-     * 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?: string[]): string;
-}
+export declare class DyFM_UUID {
+    /**
+     * 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?: string[]): string;
+}
 //# sourceMappingURL=uuid.util.d.ts.map

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

@@ -1,39 +1,39 @@
-"use strict";
-/* let UUID: any;
-
-try {
-  UUID = import('uuid');
-} catch {
-  console.log(
-    '❌ uuid package not found, please install it with: pnpm add uuid'
-  );
-} */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_UUID = void 0;
-const tslib_1 = require("tslib");
-const UUID = tslib_1.__importStar(require("uuid"));
-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;
-    }
-}
-exports.DyFM_UUID = DyFM_UUID;
+"use strict";
+/* let UUID: any;
+
+try {
+  UUID = import('uuid');
+} catch {
+  console.log(
+    '❌ uuid package not found, please install it with: pnpm add uuid'
+  );
+} */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_UUID = void 0;
+const tslib_1 = require("tslib");
+const UUID = tslib_1.__importStar(require("uuid"));
+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;
+    }
+}
+exports.DyFM_UUID = DyFM_UUID;
 //# sourceMappingURL=uuid.util.js.map