@lilaquadrat/design-core 0.2.2 → 0.3.0

package/src/libs/Models.class.ts

@@ -35,7 +35,7 @@ interface ModelOptions {
    */
   extends?: string
 }
-// eslint-disable-next-line no-unused-vars
+ 
 type ModelHook<T> = (data: T) => void;
 
 interface ModelHooks<T> {
@@ -50,424 +50,422 @@ interface ModelHooks<T> {
 
 class Models {
 
-  registeredModels: string[] = [];
+    registeredModels: string[] = [];
 
-  declarations: Record<string, ModelDeclaration<T>> = {};
+    declarations: Record<string, ModelDeclaration<T>> = {};
 
-  options: Record<string, ModelOptions> = {};
+    options: Record<string, ModelOptions> = {};
 
-  hooks: Record<string, ModelHooks<T>> = {};
+    hooks: Record<string, ModelHooks<T>> = {};
 
-  debug: boolean = false;
+    debug: boolean = false;
 
-  constructor (debug: boolean = false) {
+    constructor(debug: boolean = false) {
 
-    this.debug = debug;
+        this.debug = debug;
 
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  register<T>(name: string, declaration: ModelDeclaration<T>, hooks?: ModelHooks<T>, options?: ModelOptions): void;
-
-  // eslint-disable-next-line no-unused-vars
-  register<T, E>(name: string, declaration: ModelDeclarationExtended<T, E>, hooks: ModelHooks<T> | undefined, options: ModelOptions): void;
+    }
+     
+    register<T>(name: string, declaration: ModelDeclaration<T>, hooks?: ModelHooks<T>, options?: ModelOptions): void;
+     
+    register<T, E>(name: string, declaration: ModelDeclarationExtended<T, E>, hooks: ModelHooks<T> | undefined, options: ModelOptions): void;
 
-  register<T, E> (name: string, declaration: ModelDeclaration<T > | ModelDeclarationExtended<T, E>, hooks: ModelHooks<T> | undefined, options?: ModelOptions) {
+    register<T, E>(name: string, declaration: ModelDeclaration<T > | ModelDeclarationExtended<T, E>, hooks: ModelHooks<T> | undefined, options?: ModelOptions) {
 
-    if (this.debug) console.debug(`registed model ${name}`);
-    // this.registeredModels[name] = declaration;
-    this.registeredModels.push(name);
-    this.declarations[name] = options?.extends ? this.extendDeclaration(declaration, options.extends) : declaration;
+        if (this.debug) console.debug(`registed model ${name}`);
+        // this.registeredModels[name] = declaration;
+        this.registeredModels.push(name);
+        this.declarations[name] = options?.extends ? this.extendDeclaration(declaration, options.extends) : declaration;
     
-    if(options) this.options[name] = options;
-    if(hooks) this.hooks[name] = hooks;
+        if(options) this.options[name] = options;
+        if(hooks) this.hooks[name] = hooks;
 
-  }
+    }
 
-  getDeclaration (name: string): ModelDeclaration<any> {
+    getDeclaration(name: string): ModelDeclaration<any> {
 
-    if (!this.declarations[name]) console.error(`DECLARATION_NOT_FOUND - ${name}`);
+        if (!this.declarations[name]) console.error(`DECLARATION_NOT_FOUND - ${name}`);
 
-    return this.declarations[name] as ModelDeclaration<any> ;
+        return this.declarations[name] as ModelDeclaration<any> ;
 
-  }
+    }
 
-  getOptions (name: string): ModelOptions {
+    getOptions(name: string): ModelOptions {
 
-    return this.options[name];
+        return this.options[name];
 
-  }
+    }
 
-  extendDeclaration (declaration: ModelDeclaration, extendBase: string) {
+    extendDeclaration(declaration: ModelDeclaration, extendBase: string) {
 
-    const base = this.getDeclaration(extendBase);
+        const base = this.getDeclaration(extendBase);
 
-    if (!base) throw new Error('MODELS_EXTENDS_BASE_NOT_FOUND');
+        if (!base) throw new Error('MODELS_EXTENDS_BASE_NOT_FOUND');
 
-    return { ...base, ...declaration };
+        return { ...base, ...declaration };
 
-  }
+    }
 
-  prepareTargetObject<T> (name: string, data: T & { uuid?: string }, usecase?: 'save' | 'add' | 'clone') {
+    prepareTargetObject<T>(name: string, data: T & { uuid?: string }, usecase?: 'save' | 'add' | 'clone') {
 
-    const targetObject: GenericModel = {};
-    const options = this.getOptions(name);
+        const targetObject: GenericModel = {};
+        const options = this.getOptions(name);
 
-    if (options?.uuid) {
+        if (options?.uuid) {
 
-      if (usecase === 'clone') {
+            if (usecase === 'clone') {
 
-        targetObject.uuid = uuid();
+                targetObject.uuid = uuid();
 
-      } else {
+            } else {
 
-        targetObject.uuid = data.uuid || uuid();
+                targetObject.uuid = data.uuid || uuid();
 
-      }
+            }
 
-    }
+        }
 
-    if (options?.nameAsType) {
+        if (options?.nameAsType) {
 
-      targetObject.type = name;
+            targetObject.type = name;
 
-    }
+        }
 
-    return targetObject;
+        return targetObject;
 
-  }
+    }
 
-  add<T> (data: Partial<T>, name: string, declaration?: ModelDeclaration<T>): T {
+    add<T>(data: Partial<T>, name: string, declaration?: ModelDeclaration<T>): T {
 
-    const modelData = this.setDataV2(data, this.prepareTargetObject(name, data, 'add'), declaration || this.getDeclaration(name), name, 'add');
+        const modelData = this.setDataV2(data, this.prepareTargetObject(name, data, 'add'), declaration || this.getDeclaration(name), name, 'add');
 
-    // if (this.hooks[name]?.preAdd) this.hooks[name].preAdd(modelData);
+        // if (this.hooks[name]?.preAdd) this.hooks[name].preAdd(modelData);
 
-    return modelData as T;
+        return modelData as T;
 
-  }
+    }
 
-  save<T> (data: Partial<T>, name: string, declaration?: ModelDeclaration<T>): T {
+    save<T>(data: Partial<T>, name: string, declaration?: ModelDeclaration<T>): T {
 
-    const modelData = this.setDataV2(data, this.prepareTargetObject(name, data, 'save'), declaration || this.getDeclaration(name), name, 'save') as T;
+        const modelData = this.setDataV2(data, this.prepareTargetObject(name, data, 'save'), declaration || this.getDeclaration(name), name, 'save') as T;
 
-    // if (this.hooks[name]?.postSave) this.hooks[name].postSave(modelData);
+        // if (this.hooks[name]?.postSave) this.hooks[name].postSave(modelData);
 
-    return modelData as T;
+        return modelData as T;
 
-  }
+    }
 
-  clone<T> (data: Partial<T>, name: string, declaration?: ModelDeclaration<T>): T {
+    clone<T>(data: Partial<T>, name: string, declaration?: ModelDeclaration<T>): T {
 
-    const modelData = this.setDataV2(data, this.prepareTargetObject(name, data, 'clone'), declaration || this.getDeclaration(name), name, 'clone') as T;
+        const modelData = this.setDataV2(data, this.prepareTargetObject(name, data, 'clone'), declaration || this.getDeclaration(name), name, 'clone') as T;
 
-    // if (this.hooks[name].postClone) this.hooks[name].postClone(data);
+        // if (this.hooks[name].postClone) this.hooks[name].postClone(data);
 
-    return modelData as T;
+        return modelData as T;
 
-  }
+    }
 
-  setDataV2<T> (data: Partial<T>, targetObject: GenericModel | GenericModel[], declaration: ModelDeclaration, name: string, usecase: 'save' | 'add' | 'clone') {
+    setDataV2<T>(data: Partial<T>, targetObject: GenericModel | GenericModel[], declaration: ModelDeclaration, name: string, usecase: 'save' | 'add' | 'clone') {
 
-    if (this.debug) console.debug(data, declaration, targetObject, usecase);
+        if (this.debug) console.debug(data, declaration, targetObject, usecase);
 
-    const keys = Object.keys(declaration || {});
+        const keys = Object.keys(declaration || {});
 
-    // if (typeof this.legacy === 'function' && legacy) {
+        // if (typeof this.legacy === 'function' && legacy) {
 
-    //   if (data) data = this.legacy(data);
+        //   if (data) data = this.legacy(data);
 
-    // }
+        // }
 
-    // if (typeof this.onSave === 'function' && usecase === 'save') {
+        // if (typeof this.onSave === 'function' && usecase === 'save') {
 
-    //   if (data) data = this.onSave(data);
+        //   if (data) data = this.onSave(data);
 
-    // }
+        // }
 
-    if (usecase === 'save') {
+        if (usecase === 'save') {
 
-      if (this.hooks[name]?.preSave) this.hooks[name].preSave(data);
+            if (this.hooks[name]?.preSave) this.hooks[name].preSave(data);
 
-    }
+        }
 
-    if (usecase === 'clone') {
+        if (usecase === 'clone') {
 
-      if (this.hooks[name]?.preClone) this.hooks[name].preClone(data);
+            if (this.hooks[name]?.preClone) this.hooks[name].preClone(data);
 
-    }
+        }
 
-    if (usecase === 'add') {
+        if (usecase === 'add') {
 
-      if (this.hooks[name]?.preAdd) this.hooks[name].preAdd(data);
+            if (this.hooks[name]?.preAdd) this.hooks[name].preAdd(data);
 
-    }
+        }
 
-    if (usecase === 'save' && Models.isEmpty(data)) return targetObject;
+        if (usecase === 'save' && Models.isEmpty(data)) return targetObject;
 
-    // remove the changed flag on save
-    // if (usecase === 'save') {
+        // remove the changed flag on save
+        // if (usecase === 'save') {
 
-    // delete this.changed;
+        // delete this.changed;
 
-    // }
+        // }
 
-    // delete this.legacy;
-    // delete this.onSave;
-    // delete this.onAdd;
+        // delete this.legacy;
+        // delete this.onSave;
+        // delete this.onAdd;
 
-    keys.forEach((keyName: string) => {
+        keys.forEach((keyName: string) => {
 
-      if (this.debug) console.debug('START', keyName, data, declaration, declaration[keyName]);
+            if (this.debug) console.debug('START', keyName, data, declaration, declaration[keyName]);
 
-      const currentDeclaration = declaration[keyName];
-      let currentData: any;
-      let safeData: Partial<T>;
+            const currentDeclaration = declaration[keyName];
+            let currentData: any;
+            let safeData: Partial<T>;
 
-      if (data && !Models.isEmpty(data)) safeData = hardCopy<Partial<T>>(data);
-      if (safeData && safeData[keyName]) currentData = hardCopy(safeData[keyName]);
+            if (data && !Models.isEmpty(data)) safeData = hardCopy<Partial<T>>(data);
+            if (safeData && safeData[keyName]) currentData = hardCopy(safeData[keyName]);
 
-      if (usecase === 'save' && Models.isEmpty(currentData)) return;
+            if (usecase === 'save' && Models.isEmpty(currentData)) return;
 
-      /**
+            /**
       * SPECIAL CASE type
       * dont override the type of the module
       */
-      // if (name === 'type' && currentData) {
+            // if (name === 'type' && currentData) {
 
-      //   targetObject.type = currentData;
-      //   return;
+            //   targetObject.type = currentData;
+            //   return;
 
-      // }
+            // }
 
-      if ('type' in currentDeclaration) {
+            if ('type' in currentDeclaration) {
 
-        if (currentData) {
+                if (currentData) {
            
-          if (this.debug) console.debug('CHECK CURRENTDATA TYPE', typeof currentData === currentDeclaration.type, currentDeclaration.type, keyName, currentData, currentDeclaration);
+                    if (this.debug) console.debug('CHECK CURRENTDATA TYPE', typeof currentData === currentDeclaration.type, currentDeclaration.type, keyName, currentData, currentDeclaration);
            
-          if (typeof currentData !== currentDeclaration.type && currentDeclaration.type !== 'array' && !Models.isModel(currentDeclaration)) currentData = undefined;
+                    if (typeof currentData !== currentDeclaration.type && currentDeclaration.type !== 'array' && !Models.isModel(currentDeclaration)) currentData = undefined;
 
-        }
+                }
 
-        /**
+                /**
         * if usecase is save an no data is given, dont add default values
         */
-        if (usecase === 'save' && Models.isEmpty(currentData)) {
+                if (usecase === 'save' && Models.isEmpty(currentData)) {
 
-          // delete declaration[name];
-          return;
+                    // delete declaration[name];
+                    return;
 
-        }
+                }
 
-        // if (name === 'legacy') return targetObject;
-        // if (name === 'onSave') return targetObject;
+                // if (name === 'legacy') return targetObject;
+                // if (name === 'onSave') return targetObject;
 
-        /**
+                /**
         * string and number gets assigned
         */
-        if (['string', 'number', 'boolean', 'object'].includes(currentDeclaration.type)) {
+                if (['string', 'number', 'boolean', 'object'].includes(currentDeclaration.type)) {
 
-          targetObject[keyName] = currentData || Models.getDefaultValue(currentDeclaration);
+                    targetObject[keyName] = currentData || Models.getDefaultValue(currentDeclaration);
 
-        }
+                }
 
-        /**
+                /**
         * array
         */
-        if (currentDeclaration.type === 'array') {
+                if (currentDeclaration.type === 'array') {
 
-          const arrayContains = currentDeclaration.contains;
+                    const arrayContains = currentDeclaration.contains;
 
-          if ('type' in arrayContains) {
+                    if ('type' in arrayContains) {
 
-            if (['string', 'number'].includes(arrayContains.type)) {
+                        if (['string', 'number'].includes(arrayContains.type)) {
 
-              if (this.debug) console.debug('SET ARRAY STRING/NUMBER', currentData);
+                            if (this.debug) console.debug('SET ARRAY STRING/NUMBER', currentData);
 
-              targetObject[keyName] = currentData?.slice(0) || Models.getDefaultValue(currentDeclaration);
+                            targetObject[keyName] = currentData?.slice(0) || Models.getDefaultValue(currentDeclaration);
 
-            }
+                        }
 
-            if (arrayContains.type === 'object') {
+                        if (arrayContains.type === 'object') {
 
-              targetObject[keyName] = [];
+                            targetObject[keyName] = [];
 
-              // only add non empty objects to the array
-              currentData?.forEach((single) => {
+                            // only add non empty objects to the array
+                            currentData?.forEach((single) => {
 
-                // skip if single is empty
-                if (usecase === 'save' && Models.isEmpty(single)) return;
+                                // skip if single is empty
+                                if (usecase === 'save' && Models.isEmpty(single)) return;
 
-                // only add if the result is not empty
-                if (!Models.isEmpty(single)) targetObject[keyName].push(single);
+                                // only add if the result is not empty
+                                if (!Models.isEmpty(single)) targetObject[keyName].push(single);
 
-              });
+                            });
 
-              if (!targetObject[keyName].length) delete targetObject[keyName];
+                            if (!targetObject[keyName].length) delete targetObject[keyName];
 
-            }
+                        }
 
-          }
+                    }
 
-          if ('model' in arrayContains) {
+                    if ('model' in arrayContains) {
 
-            if (this.debug) console.debug('SET ARRAY MODEL', keyName, currentData, arrayContains?.model);
+                        if (this.debug) console.debug('SET ARRAY MODEL', keyName, currentData, arrayContains?.model);
 
-            targetObject[keyName] = [];
+                        targetObject[keyName] = [];
 
-            if (this.debug) console.debug(keyName, currentData);
+                        if (this.debug) console.debug(keyName, currentData);
 
-            /**
+                        /**
              * currentdata could be an array with an empty object [{}] which will not count as empty for the Model.isEmpty function
              * therefore we need to handle the possible empty data here
              */
 
-            if (currentData) {
+                        if (currentData) {
 
-              currentData?.forEach((single) => {
+                            currentData?.forEach((single) => {
 
-                // skip if single is empty
-                if (usecase === 'save' && Models.isEmpty(single)) return;
+                                // skip if single is empty
+                                if (usecase === 'save' && Models.isEmpty(single)) return;
 
-                const pushData = this.setDataV2(single, {}, this.getDeclaration(arrayContains?.model), arrayContains?.model, usecase);
+                                const pushData = this.setDataV2(single, {}, this.getDeclaration(arrayContains?.model), arrayContains?.model, usecase);
 
-                // only add if the result is not empty
-                if (!Models.isEmpty(pushData)) targetObject[keyName].push(pushData);
+                                // only add if the result is not empty
+                                if (!Models.isEmpty(pushData)) targetObject[keyName].push(pushData);
 
-              });
+                            });
 
-              if (!targetObject[keyName].length) delete targetObject[keyName];
+                            if (!targetObject[keyName].length) delete targetObject[keyName];
 
-            } else if (usecase !== 'save') {
+                        } else if (usecase !== 'save') {
 
-              targetObject[keyName].push(this.setDataV2({}, {}, this.getDeclaration(arrayContains?.model), arrayContains?.model, usecase));
+                            targetObject[keyName].push(this.setDataV2({}, {}, this.getDeclaration(arrayContains?.model), arrayContains?.model, usecase));
 
-            }
+                        }
 
-            if ('defaultItems' in currentDeclaration && usecase !== 'save') {
+                        if ('defaultItems' in currentDeclaration && usecase !== 'save') {
 
-              if (targetObject[keyName].length < currentDeclaration.defaultItems) {
+                            if (targetObject[keyName].length < currentDeclaration.defaultItems) {
 
-                const neededItems = currentDeclaration.defaultItems - targetObject[keyName].length;
+                                const neededItems = currentDeclaration.defaultItems - targetObject[keyName].length;
 
-                for (let index = 0; index < neededItems; index += 1) {
+                                for (let index = 0; index < neededItems; index += 1) {
 
-                  targetObject[keyName].push(this.setDataV2({}, {}, this.getDeclaration(arrayContains?.model), arrayContains?.model, usecase));
+                                    targetObject[keyName].push(this.setDataV2({}, {}, this.getDeclaration(arrayContains?.model), arrayContains?.model, usecase));
 
-                }
+                                }
 
-              }
+                            }
 
-            }
+                        }
 
-          }
+                    }
 
-        }
+                }
 
-      }
+            }
 
-      /**
+            /**
       * if its an object, it will be a child model
       */
-      if ('model' in currentDeclaration) {
+            if ('model' in currentDeclaration) {
 
-        if (this.debug) console.debug('its a model', keyName, currentDeclaration, currentDeclaration?.model, targetObject);
+                if (this.debug) console.debug('its a model', keyName, currentDeclaration, currentDeclaration?.model, targetObject);
 
-        // if (usecase === 'save' && (!currentData || (Array.isArray(currentData) && !currentData.length))) {
+                // if (usecase === 'save' && (!currentData || (Array.isArray(currentData) && !currentData.length))) {
 
-        //   // delete declaration[name];
-        //   return;
+                //   // delete declaration[name];
+                //   return;
 
-        // 
+                // 
 
-        targetObject[keyName]= this.setDataV2(currentData, {}, this.getDeclaration(currentDeclaration?.model), currentDeclaration?.model, usecase);
+                targetObject[keyName]= this.setDataV2(currentData, {}, this.getDeclaration(currentDeclaration?.model), currentDeclaration?.model, usecase);
 
-        if (usecase === 'save') {
+                if (usecase === 'save') {
 
-          if (this.debug) console.debug(124, this[name], Object.keys(this[name]).length);
+                    if (this.debug) console.debug(124, this[name], Object.keys(this[name]).length);
 
-          if (Models.isEmpty(targetObject[keyName])) {
+                    if (Models.isEmpty(targetObject[keyName])) {
 
-            delete targetObject[keyName];
+                        delete targetObject[keyName];
 
-          }
+                    }
 
-        }
+                }
 
-      }
+            }
 
-    });
+        });
 
-    return targetObject;
+        return targetObject;
 
-  }
+    }
 
-  static isEmpty (data: any[] | Record<string, any>) {
+    static isEmpty(data: any[] | Record<string, any>) {
 
-    if (!data) return true;
+        if (!data) return true;
 
-    if (Array.isArray(data)) {
+        if (Array.isArray(data)) {
 
-      return !data.length;
+            return !data.length;
 
-    }
+        }
 
-    if (typeof data === 'object') {
+        if (typeof data === 'object') {
 
-      return !Object.keys(data).length;
+            return !Object.keys(data).length;
 
-    }
+        }
 
-    return false;
+        return false;
 
-  }
+    }
 
-  static isModel (declaration: SingleDeclaration) {
+    static isModel(declaration: SingleDeclaration) {
 
-    return 'model' in declaration;
+        return 'model' in declaration;
 
-  }
+    }
 
-  static getDefaultValue (declaration: SingleDeclaration) {
+    static getDefaultValue(declaration: SingleDeclaration) {
 
-    if (declaration.default) {
+        if (declaration.default) {
 
-      return declaration.default;
+            return declaration.default;
 
-    }
+        }
 
-    if ('type' in declaration) {
+        if ('type' in declaration) {
 
-      if (declaration.type === 'string') {
+            if (declaration.type === 'string') {
 
-        return '';
+                return '';
 
-      }
+            }
 
-      if (declaration.type === 'number') {
+            if (declaration.type === 'number') {
 
-        return 0;
+                return 0;
 
-      }
+            }
 
-      if (declaration.type === 'boolean') {
+            if (declaration.type === 'boolean') {
 
-        return false;
+                return false;
 
-      }
+            }
 
-      if (declaration.type === 'array') {
+            if (declaration.type === 'array') {
 
-        return [];
+                return [];
 
-      }
+            }
 
-    }
+        }
 
-    return null;
+        return null;
 
-  }
+    }
 
 }
 
@@ -475,8 +473,8 @@ const ModelsClass = new Models();
 
 export default ModelsClass;
 export {
-  Models
+    Models
 };
 export type {
-  ModelDeclaration, ModelDeclarationExtended, ModelOptions, ModelHooks, SingleDeclaration
+    ModelDeclaration, ModelDeclarationExtended, ModelOptions, ModelHooks, SingleDeclaration
 };