.eslintrc.js

@@ -1,52 +0,0 @@
-module.exports = {
-  // 'plugins': ['jest'],
-  'env': {
-    'commonjs': true,
-    'es6': true,
-    'node': true,
-    // 'jest/globals': true,
-  },
-  'extends': 'eslint:recommended',
-  'globals': {
-    'Atomics': 'readonly',
-    'SharedArrayBuffer': 'readonly',
-  },
-  'parserOptions': {
-    'ecmaVersion': 2018,
-    'sourceType': 'module',
-  },
-  'rules': {
-    'indent': [
-      'error',
-      2,
-    ],
-    'linebreak-style': [
-      'error',
-      'unix',
-    ],
-    'quotes': [
-      'error',
-      'single',
-      { 'avoidEscape': true },
-    ],
-    'semi': [
-      'error',
-      'never',
-    ],
-    'comma-dangle': [
-      'error',
-      'always-multiline',
-    ],
-    'arrow-parens': [
-      'error',
-      'as-needed',
-    ],
-    'no-var': [
-      'error',
-    ],
-    'prefer-const': ['error', {
-      'destructuring': 'all',
-      'ignoreReadBeforeAssign': true,
-    }],
-  },
-}

.gitignore

@@ -1,2 +1 @@
-/node_modules/
+node_modules/
-/.idea/

README.md

@@ -1,25 +1,10 @@
-# MCF-Objects
+# MCF-Components-Lib
 
-Se trata de una librería para la gestión de objetos que añade tipos estáticos y verificaciones.
+This library exports an unique method to render components using *React* and *Material-UI* through a javascript object where is placed all
+the information needed.
 
-Admite los siguientes tipos básicos:
+The method is **render**
-  - String
-  - Number
-  - Boolean
-  - Array
-  - Enum
 
-  Mediante la definición de los objetos estáticos se pueden establecer límites a los valores, listas de valores permitidos...
+## Installation
 
-
+To install the library you can get the repository or install it as a dependency.
-## Entorno de desarrollo
-
-La bibioteca se transpila usando `babel` y se compila con `webpack`.
-
-
-## Arquitectura
-
-En el archivo `index.js`, se exporta la clase definedObject.
-
-El constructor de clase lee la definición pasada como argumento cuando crea una instancia de clase y efectúa las verificaciones necesarias antes de devolver dicha instancia.
-Cuando se asignan valores a los campos del objeto también se realizar las verificaciones indicadas sobre estos.

package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcf-objects",
-  "version": "0.2.0",
+  "version": "0.1.2",
-  "description": "Library to create typed objects",
+  "description": "Library to create custom typed objects with custom types",
   "main": "dist/mcf-objects.js",
   "scripts": {
     "start": "webpack-dev-server --open --config webpack.dev.js",
@@ -10,16 +10,15 @@
     "test:watch": "jest --watch"
   },
   "devDependencies": {
-    "@babel/core": "^7.14.6",
+    "@babel/core": "^7.7.5",
-    "@babel/plugin-proposal-class-properties": "^7.14.5",
+    "@babel/plugin-proposal-class-properties": "^7.8.3",
-    "@babel/preset-env": "^7.14.7",
+    "@babel/preset-env": "^7.7.6",
-    "@babel/preset-react": "^7.14.5",
+    "@babel/preset-react": "^7.7.4",
-    "babel-loader": "^8.2.2",
+    "babel-loader": "^8.0.6",
-    "eslint": "^7.29.0",
     "jest": "^24.9.0",
-    "webpack": "^4.46.0",
+    "webpack": "^4.41.3",
-    "webpack-cli": "^3.3.12",
+    "webpack-cli": "^3.3.10",
-    "webpack-dev-server": "^3.11.2",
+    "webpack-dev-server": "^3.9.0",
     "webpack-merge": "^4.2.2"
   },
   "dependencies": {}

src/definedObject.js

@@ -1,65 +0,0 @@
-import MCF_TypeFactory from './types/typeFactory'
-
-
-
-export default class MCF_DefinedObject {
-  constructor(definition) {
-    this.definition = definition
-    this.validations = {}
-    this.fields = MCF_TypeFactory.buildDefinedObject(this)
-    this.validateValue(definition.values)
-    this.setValue(definition.values)
-  }
-
-  getValue() {
-    const value = {}
-    for (const field in this.fields) {
-      value[field] = this.fields[field].value
-    }
-    return value
-  }
-
-  setValue(value) {
-    for (const valueKey in value) {
-      if (value[valueKey] === undefined) {
-        this.fields[valueKey].value = undefined
-      } else {
-        if (this.fields[valueKey] === undefined) {
-          throw new Error(`The field ${valueKey} doesn't exist in the current DefinedObject: ${JSON.stringify(Object.keys(this.fields), null, 2)}`)
-        }
-        this.fields[valueKey].setValue(value[valueKey])
-      }
-    }
-  }
-
-  getDefinition() {
-    return this.definition
-  }
-
-  validateValue(value) {
-    for (const field in this.definition.fields) {
-      if (value[field] === undefined || value === null) {
-        if (this.definition.fields[field].required === true) {
-          throw new Error(`The field ${field} is required`)
-        }
-        if (this.definition.fields[field].defaultValue !== undefined) {
-          value[field] = this.definition.fields[field].defaultValue
-        }
-        if (this.definition.fields[field].null === false) {
-          throw new Error(`The field ${field} can't be undefined`)
-        }
-      }
-    }
-  }
-
-  updateArrayField(field, arrayItem, mustBeIncluded) {
-    const fieldArray = this.getValue()[field] || []
-
-    if (!fieldArray.includes(arrayItem) && mustBeIncluded) fieldArray.push(arrayItem)
-    if (fieldArray.includes(arrayItem) && !mustBeIncluded) fieldArray.splice(fieldArray.indexOf(arrayItem), 1)
-
-    const newValue = {}
-    newValue[field] = fieldArray
-    this.setValue(newValue)
-  }
-}

src/index.js

@@ -1,14 +1,235 @@
-//TODO: Hacer nuevo tipo de dato: array-enum -> array en el que los elementos solo pueden tomar determinados valores
+// --== OBJECTS LIBRARY ==--
-//TODO: Que no sea necesario pasar un objeto vacío ({}) para instanciar un mcfDefinedObject sin argumentos
+// ========================================
-//TODO: Modificar getValue para que acepte como parámetro el nombre del campo que se quiere obtener: getvalue(fieldName)
 
+class MCF_Type {
+    constructor(definition){
+        this.definition = definition;
+        this.validations = {};
 
-import MCF_DefinedObject from './definedObject'
+    }
-import MCF_File from './objects/file'
 
+    setValue(value){
+        this.validate(value);
+        this.value = value;
+    }
 
+    getValue(){
+        return this.value;
+    }
 
-export {
+    validate(value){
-  MCF_DefinedObject as DefinedObject,
+        for (let validation in this.validations){
-  MCF_File as File,
+            this.validations[validation](value, this.definition);
+        }
+    }
 }
+class MCF_String extends MCF_Type {
+    constructor(definition){
+        super(definition);
+        this.addValidations();
+    }
+
+    addValidations(){
+        this.validations.type = function(value) {
+            if (typeof (value) !== "string") {
+                throw new Error(`MCF_String creation: the type of ${value} isn't "string"`);
+            }
+        };
+
+        for (let param in this.definition){
+            switch (param) {
+                case 'maxLength':
+                    this.validations.maxLength = function(value, definition){
+                        if (value.length > definition.maxLength){
+                            throw new Error(`MCF_String creation: the length of the string "${value}" is higher than the maximum defined: ${definition.maxLength}`);
+                        }
+                    };
+                    break;
+                case 'minLength':
+                    this.validations.minLength = function(value, definition){
+                        if (value.length < definition.minLength){
+                            throw new Error(`MCF_String creation: the length of the string "${value}" is lower than the minimum defined: ${definition.minLength}`);
+                        }
+                    };
+                    break;
+            }
+        }
+    }
+}
+class MCF_Number extends MCF_Type{
+    constructor(definition){
+        super(definition);
+        this.addValidations();
+    }
+
+    addValidations(){
+        this.validations.type = function(value) {
+            if (typeof (value) !== "number") {
+                throw new Error(`MCF_Number creation: the type of the value ${value} isn't "number"`);
+            }
+        };
+
+        for (let param in this.definition){
+            switch (param) {
+                case 'max':
+                    this.validations.max = function(value, definition){
+                        if (value > definition.max){
+                            throw new Error(`MCF_Number creation: the value ${value} is higher than the maximum defined: ${definition.max}`);
+                        }
+                    };
+                    break;
+                case 'min':
+                    this.validations.min = function(value, definition){
+                        if (value < definition.min){
+                            throw new Error(`MCF_Number creation: the value ${value} is lower than the minimum defined: ${definition.min}`);
+                        }
+                    };
+                    break;
+            }
+        }
+    }
+}
+class MCF_Boolean extends MCF_Type{
+    constructor(definition){
+        super(definition);
+        this.addValidations();
+    }
+
+    addValidations(){
+        this.validations.type = function(value) {
+            if (typeof (value) !== "boolean") {
+                throw new Error(`MCF_Boolean creation: the type of the value ${value} isn't "boolean"`);
+            }
+        };
+    }
+}
+class MCF_Array extends MCF_Type {
+    constructor(definition){
+        super(definition);
+        this.addValidations();
+    }
+
+    addValidations(){
+        this.validations.type = function(value) {
+            if (!Array.isArray(value)) {
+                throw new Error(`MCF_Array creation: the type of ${value} isn't "array"`);
+            }
+        };
+
+        for (let param in this.definition){
+            switch (param) {
+                case 'maxLength':
+                    this.validations.maxLength = function(value, definition){
+                        if (value.length > definition.maxLength){
+                            throw new Error(`MCF_Array creation: the length of the array "${value}" is higher than the maximum defined: ${definition.maxLength}`);
+                        }
+                    };
+                    break;
+                case 'minLength':
+                    this.validations.minLength = function(value, definition){
+                        if (value.length < definition.minLength){
+                            throw new Error(`MCF_Array creation: the length of the array "${value}" is lower than the minimum defined: ${definition.minLength}`);
+                        }
+                    };
+                    break;
+            }
+        }
+    }
+}
+class MCF_Enum extends MCF_Type{
+    constructor(definition){
+        super(definition);
+        this.addValidations();
+    }
+
+    addValidations(){
+        this.validations.isAvailable = function(value, definition){
+            const valueIsAvailable = definition.availableValues.reduce(function(isAvailable, availableValue){
+                if (value === availableValue) return true;
+                return isAvailable;
+            }, false);
+            if (!valueIsAvailable){
+                throw new Error(`MCF_Enum creation: the value "${value}" isn't one of the next values, included in the field definition: ${definition.availableValues.toString()}`);
+            }
+        }
+    }
+}
+class MCF_TypeFactory {
+    static buildDefinedObject(definedObject) {
+        const objectDefinition = definedObject.getDefinition();
+        let fields = objectDefinition.fields;
+        let dictionary = {};
+        for (let field in fields) {
+            switch (fields[field]['TYPE']) {
+                case 'string':
+                    dictionary[field] = new MCF_String(fields[field]);
+                    break;
+                case 'number':
+                    dictionary[field] = new MCF_Number(fields[field]);
+                    break;
+                case 'boolean':
+                    dictionary[field] = new MCF_Boolean(fields[field]);
+                    break;
+                case 'enum':
+                    dictionary[field] = new MCF_Enum(fields[field]);
+                    break;
+                case 'array':
+                    dictionary[field] = new MCF_Array(fields[field]);
+                    break;
+            }
+        }
+        return dictionary;
+    }
+}
+class MCF_DefinedObject {
+    constructor(definition){
+        this.definition = definition;
+        this.validations = {};
+        this.fields = MCF_TypeFactory.buildDefinedObject(this);
+        this.setValue(definition.value)
+    }
+
+    getDefinition(){
+        return this.definition;
+    }
+
+    getValue(){
+        let value = {};
+        for (let field in this.fields){
+            value[field] = this.fields[field].value;
+        }
+        return value;
+    }
+
+    setValue(value){
+        for (let field in this.definition.fields){
+            if (value[field] === undefined || value === null){
+                if (this.definition.fields[field].required === true){
+                    throw new Error(`The field ${field} is required`);
+                }
+                if (this.definition.fields[field].defaultValue !== undefined){
+                    value[field] = this.definition.fields[field].defaultValue;
+                }
+                if (this.definition.fields[field].null === false){
+                    throw new Error(`The field ${field} can't be undefined`);
+                }
+            }
+        }
+
+        for (let field in value){
+            if (value[field] === undefined){
+                this.fields[field].value = undefined;
+            } else {
+                this.fields[field].setValue(value[field]);
+            }
+        }
+    }
+
+    setPropertiesValue(value){
+        for (let field in value){
+            this.fields[field].setValue(value[field]);
+        }
+    }
+}
+
+export {MCF_DefinedObject as definedObject};

src/objects/file.js

@@ -1,19 +0,0 @@
-import MCF_DefinedObject from '../definedObject'
-
-
-
-const fileFieldsDefition = {
-  name:      { TYPE: 'string', required: true },
-  extension: { TYPE: 'string' },
-  mimeType:  { TYPE: 'string' },
-  content:   { TYPE: 'string', defaultValue: '' },
-}
-
-export default class MCF_File extends MCF_DefinedObject {
-  constructor(definition) {
-    super({
-      fields: { ...fileFieldsDefition, ...definition.fields },
-      values: definition.values ? definition.values : definition,
-    })
-  }
-}

src/types/array.js

@@ -1,37 +0,0 @@
-import MCF_BaseType from './base'
-
-
-
-export default class MCF_Array extends MCF_BaseType {
-  constructor(definition) {
-    super(definition)
-    this.addValidations()
-  }
-
-  addValidations() {
-    this.validations.type = function(value) {
-      if (!Array.isArray(value)) {
-        throw new Error(`MCF-Objects ==> MCF_Array validation: the type of ${value} isn't "array"`)
-      }
-    }
-
-    for (const param in this.definition) {
-      switch (param) {
-      case 'maxLength':
-        this.validations.maxLength = function(value, definition) {
-          if (value.length > definition.maxLength) {
-            throw new Error(`MCF-Objects ==> MCF_Array validation: the length of the array "${value}" is higher than the maximum defined: ${definition.maxLength}`)
-          }
-        }
-        break
-      case 'minLength':
-        this.validations.minLength = function(value, definition) {
-          if (value.length < definition.minLength) {
-            throw new Error(`MCF-Objects ==> MCF_Array validation: the length of the array "${value}" is lower than the minimum defined: ${definition.minLength}`)
-          }
-        }
-        break
-      }
-    }
-  }
-}

src/types/base.js

@@ -1,21 +0,0 @@
-export default class MCF_BaseType {
-  constructor(definition) {
-    this.definition = definition
-    this.validations = {}
-  }
-
-  getValue() {
-    return this.value
-  }
-
-  setValue(value) {
-    this.validate(value)
-    this.value = value
-  }
-
-  validate(value) {
-    for (const validation in this.validations) {
-      this.validations[validation](value, this.definition)
-    }
-  }
-}

src/types/boolean.js

@@ -1,18 +0,0 @@
-import MCF_BaseType from './base'
-
-
-
-export default class MCF_Boolean extends MCF_BaseType {
-  constructor(definition) {
-    super(definition)
-    this.addValidations()
-  }
-
-  addValidations() {
-    this.validations.type = function(value) {
-      if (typeof(value) !== 'boolean') {
-        throw new Error(`MCF-Objects ==> MCF_Boolean creation: the type of the value ${value} isn't "boolean"`)
-      }
-    }
-  }
-}

src/types/enum.js

@@ -1,22 +0,0 @@
-import MCF_BaseType from './base'
-
-
-
-export default class MCF_Enum extends MCF_BaseType {
-  constructor(definition) {
-    super(definition)
-    this.addValidations()
-  }
-
-  addValidations() {
-    this.validations.isAvailable = function(value, definition) {
-      const valueIsAvailable = definition.availableValues.reduce(function(isAvailable, availableValue) {
-        if (value === availableValue) return true
-        return isAvailable
-      }, false)
-      if (!valueIsAvailable) {
-        throw new Error(`MCF-Objects ==> MCF_Enum validation: the value "${value}" isn't one of the next values, included in the field definition: ${definition.availableValues.toString()}`)
-      }
-    }
-  }
-}

src/types/number.js

@@ -1,36 +0,0 @@
-import MCF_BaseType from './base'
-
-
-export default class MCF_Number extends MCF_BaseType {
-  constructor(definition) {
-    super(definition)
-    this.addValidations()
-  }
-
-  addValidations() {
-    this.validations.type = function(value) {
-      if (typeof(value) !== 'number') {
-        throw new Error(`MCF-Objects ==> MCF_Number validation: the type of the value ${value} isn't "number"`)
-      }
-    }
-
-    for (const param in this.definition) {
-      switch (param) {
-      case 'max':
-        this.validations.max = function(value, definition) {
-          if (value > definition.max) {
-            throw new Error(`MCF-Objects ==> MCF_Number validation: the value ${value} is higher than the maximum defined: ${definition.max}`)
-          }
-        }
-        break
-      case 'min':
-        this.validations.min = function(value, definition) {
-          if (value < definition.min) {
-            throw new Error(`MCF-Objects ==> MCF_Number validation: the value ${value} is lower than the minimum defined: ${definition.min}`)
-          }
-        }
-        break
-      }
-    }
-  }
-}

src/types/string.js

@@ -1,37 +0,0 @@
-import MCF_BaseType from './base'
-
-
-
-export default class MCF_String extends MCF_BaseType {
-  constructor(definition) {
-    super(definition)
-    this.addValidations()
-  }
-
-  addValidations() {
-    this.validations.type = function(value) {
-      if (typeof(value) !== 'string') {
-        throw new Error(`MCF-Objects ==> MCF_String validation: the type of ${value} isn't "string"`)
-      }
-    }
-
-    for (const param in this.definition) {
-      switch (param) {
-      case 'maxLength':
-        this.validations.maxLength = function(value, definition) {
-          if (value.length > definition.maxLength) {
-            throw new Error(`MCF-Objects ==> MCF_String validation: the length of the string "${value}" is higher than the maximum defined: ${definition.maxLength}`)
-          }
-        }
-        break
-      case 'minLength':
-        this.validations.minLength = function(value, definition) {
-          if (value.length < definition.minLength) {
-            throw new Error(`MCF-Objects ==> MCF_String validation: the length of the string "${value}" is lower than the minimum defined: ${definition.minLength}`)
-          }
-        }
-        break
-      }
-    }
-  }
-}

src/types/typeFactory.js

@@ -1,37 +0,0 @@
-import MCF_Array from './array'
-import MCF_Boolean from './boolean'
-import MCF_Enum from './enum'
-import MCF_Number from './number'
-import MCF_String from './string'
-
-
-
-export default class MCF_TypeFactory {
-  static buildDefinedObject(definedObject) {
-    const objectDefinition = definedObject.getDefinition()
-    const fields = objectDefinition.fields
-    const dictionary = {}
-    for (const field in fields) {
-      switch (fields[field]['TYPE']) {
-      case 'array':
-        dictionary[field] = new MCF_Array(fields[field])
-        break
-      case 'boolean':
-        dictionary[field] = new MCF_Boolean(fields[field])
-        break
-      case 'enum':
-        dictionary[field] = new MCF_Enum(fields[field])
-        break
-      case 'number':
-        dictionary[field] = new MCF_Number(fields[field])
-        break
-      case 'string':
-        dictionary[field] = new MCF_String(fields[field])
-        break
-      default:
-        throw new Error(`MCF-Objects ==> The object type ${fields[field]['TYPE']} does not exist. Check the field definition in the object definition ${objectDefinition}`)
-      }
-    }
-    return dictionary
-  }
-}

webpack.common.js

@@ -1,4 +1,4 @@
-const path = require('path')
+const path = require('path');
 
 module.exports = {
   entry: './src/index.js',
@@ -6,7 +6,7 @@ module.exports = {
     path: path.resolve(__dirname, 'dist'),
     filename: 'mcf-objects.js',
     library: 'mcfObjects',
-    libraryTarget: 'umd',
+    libraryTarget: 'umd'
   },
   module: {
     rules: [
@@ -19,4 +19,4 @@ module.exports = {
       },
     ],
   },
-}
+};

webpack.dev.js

@@ -1,5 +1,5 @@
-const merge = require('webpack-merge')
+const merge = require('webpack-merge');
-const common = require('./webpack.common.js')
+const common = require('./webpack.common.js');
 
 module.exports = merge(common, {
   mode: 'development',
@@ -7,4 +7,4 @@ module.exports = merge(common, {
   devServer: {
     contentBase: './dist',
   },
-})
+});

webpack.prod.js

@@ -1,7 +1,7 @@
-const merge = require('webpack-merge')
+const merge = require('webpack-merge');
-const common = require('./webpack.common.js')
+const common = require('./webpack.common.js');
 
 module.exports = merge(common, {
   mode: 'production',
   devtool: 'source-map',
-})
+});