@zohodesk/library-platform 1.1.10-exp.1 → 1.1.10-exp.2

package/es/library/custom-component/applications/usecases/DispatchUseCase.js

@@ -1,19 +1,42 @@
+/* eslint-disable max-lines-per-function */
+
+/* eslint-disable complexity */
+import { ACA_ERROR_OCCURRED } from "../../../../cc/component/ErrorStructure";
 import AbstractUseCase from "./AbstractUseCase";
 
 class DispatchUseCase extends AbstractUseCase {
   execute(input) {
-    let {
+    const {
       repository,
       presenter,
       eventManager
     } = this.dependencies;
-    let component = repository.getComponent();
+    const component = repository.getComponent();
+
+    if (component.canSkipDispatchingEvent(input.type)) {
+      return;
+    }
 
     try {
-      let action = component.constructAction(input);
-      eventManager.dispatch(action);
+      if (input.type === ACA_ERROR_OCCURRED) {
+        const {
+          payload
+        } = input;
+
+        if (payload.errorDetails?.isBreaking) {
+          component.setError(payload);
+          presenter.setError(payload);
+        }
+
+        const action = component.getPublicErrorEvent(payload);
+        eventManager.dispatch(action);
+      } else {
+        const action = component.constructAction(input);
+        eventManager.dispatch(action);
+      }
     } catch (e) {
-      presenter.setError([e]);
+      component.setError(e);
+      presenter.setError(e);
     }
   }
 

package/es/library/custom-component/applications/usecases/InitializeUseCase.js

@@ -6,17 +6,18 @@ class InitializeUseCase extends AbstractUseCase {
     let {
       presenter,
       jsonValidator,
-      repository,
-      schemaValidator
+      repository
     } = this.dependencies;
     let component = createComponent(input, input.helpers);
 
     try {
-      component.init(jsonValidator, input.newProps, schemaValidator);
+      component.init(jsonValidator, input.newProps);
       let state = component.getState();
       presenter.render(state);
     } catch (e) {
-      presenter.setError(e);
+      const error = component.getClassifiedErrorStructure(e);
+      component.setError(error);
+      presenter.setError(error);
     } finally {
       repository.save(component);
     }

package/es/library/custom-component/applications/usecases/MountUseCase.js

@@ -2,20 +2,24 @@ import AbstractUseCase from "./AbstractUseCase";
 
 class MountUsecase extends AbstractUseCase {
   execute() {
-    let {
+    const {
       repository,
       presenter,
       eventManager
     } = this.dependencies;
-    let component = repository.getComponent();
-    let mountAction = component.getMountAction();
-    let eventHandlers = component.getEventHandlersWrapper();
+    const component = repository.getComponent();
+    const mountAction = component.getMountAction();
+    const eventHandlers = component.getEventHandlersWrapper();
 
     try {
       eventManager.subscribe(eventHandlers);
-      eventManager.dispatch(mountAction);
+
+      if (!component.hasBreakingError()) {
+        eventManager.dispatch(mountAction);
+      }
     } catch (e) {
-      presenter.setError([e]);
+      component.setError(e);
+      presenter.setError(e);
     }
   }
 

package/es/library/custom-component/applications/usecases/UnmountUseCase.js

@@ -2,21 +2,22 @@ import AbstractUseCase from "./AbstractUseCase";
 
 class UnmountUsecase extends AbstractUseCase {
   execute() {
-    let {
+    const {
       repository,
       presenter,
       eventManager
     } = this.dependencies;
-    let component = repository.getComponent();
-    let eventHanlders = component.getEventHandlers();
-    let unmountAction = component.getUnmountAction();
+    const component = repository.getComponent();
+    const eventHanlders = component.getEventHandlers();
+    const unmountAction = component.getUnmountAction();
 
     try {
       eventManager.dispatch(unmountAction);
       eventManager.unSubscribe(eventHanlders);
       repository.clear();
     } catch (e) {
-      presenter.setError([]);
+      component.setError(null);
+      presenter.setError(null);
     }
   }
 

package/es/library/custom-component/applications/usecases/UpdatePropertyUseCase.js

@@ -2,29 +2,34 @@ import AbstractUseCase from "./AbstractUseCase";
 
 class UpdatePropertyUseCase extends AbstractUseCase {
   execute(newProps) {
-    let {
+    const {
       repository,
       jsonValidator,
       eventManager,
-      presenter,
-      schemaValidator
+      presenter
     } = this.dependencies;
-    let component = repository.getComponent();
-    let properties = component.getProperties();
-    let isUpdated = component.updateProperties(jsonValidator, newProps, schemaValidator);
+    const component = repository.getComponent();
 
-    if (isUpdated) {
-      let updatedProperties = component.getProperties();
-      let state = component.getState();
-      presenter.render(state);
-      let updatePropertyAction = component.getPropertyUpdateAction({
-        currentProperties: updatedProperties,
-        previousProperties: properties
-      });
-      eventManager.dispatch(updatePropertyAction);
-      eventManager.dispatch(component.getStateUpdatedAction({
-        state
-      }));
+    try {
+      const properties = component.getProperties();
+      const isUpdated = component.updateProperties(jsonValidator, newProps);
+
+      if (isUpdated) {
+        const updatedProperties = component.getProperties();
+        const state = component.getState();
+        presenter.render(state);
+        const updatePropertyAction = component.getPropertyUpdateAction({
+          currentProperties: updatedProperties,
+          previousProperties: properties
+        });
+        eventManager.dispatch(updatePropertyAction);
+        eventManager.dispatch(component.getStateUpdatedAction({
+          state
+        }));
+      }
+    } catch (error) {
+      component.setError(error);
+      presenter.setError(error);
     }
   }
 

package/es/library/custom-component/applications/usecases/UpdateStateUseCase.js

@@ -7,15 +7,16 @@ class UpdateStateUseCase extends AbstractUseCase {
       presenter,
       eventManager
     } = this.dependencies;
-    let component = repository.getComponent(); // let preState=component.getState();
-    // console.log(`preState ${component.getName()}`,preState)
+    let component = repository.getComponent();
+    let preState = component.getState(); // console.log(`preState ${component.getName()}`,preState)
 
     component.updateState(newState);
     let state = component.getState(); // console.log(`newState ${component.getName()}`,state)
 
     presenter.render(state);
     eventManager.dispatch(component.getStateUpdatedAction({
-      state
+      state,
+      preState
     }));
   }
 

package/es/library/custom-component/domain/entities/Behaviour.js

@@ -20,6 +20,10 @@ class Behaviour {
     return this.properties;
   }
 
+  getPropertiesClone() {
+    return this.properties.getPropertiesClone();
+  }
+
   getEventHandlers() {
     return this.eventHandlers;
   }

package/es/library/custom-component/domain/entities/Component.js

@@ -1,25 +1,75 @@
+/* eslint-disable complexity */
 import EventHandler from "./EventHandler";
+import { ERROR_OCCURRED_SUFFIX, ErrorCodes } from "../../../../cc/component/ErrorStructure";
 export default class Component {
-  constructor() {
-    this._behavioursProperties = {};
+  currentError = null;
+
+  constructor(componentProperties) {
+    this.componentProperties = componentProperties;
   }
 
-  getAllBehavioursPropertiesWithValue() {
-    let output = {};
-    Object.keys(this._behavioursProperties).forEach((value, key) => {
-      output[value] = this._behavioursProperties[value].getValue();
-    });
-    return output;
+  setLogger(logger) {
+    this.logger = logger;
   }
 
   mergeStateAndProps() {
     return { ...this._state.getState(),
-      properties: { ...this._properties.getAllPropertiesValue(),
-        ...this.getAllBehavioursPropertiesWithValue()
-      }
+      properties: this.componentProperties.getAllPropertiesValue()
     };
   }
 
+  hasBreakingError() {
+    return !!this.currentError?.errorDetails?.isBreaking;
+  }
+
+  canSkipDispatchingEvent(eventName) {
+    if (!this.hasBreakingError()) {
+      return false;
+    } // TODO: eventName.endsWith('UPDATE_PROPERTIES')
+
+
+    if (eventName.endsWith(ERROR_OCCURRED_SUFFIX)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  setError(error) {
+    error && this.logger.logError(error);
+
+    if (this.hasBreakingError()) {
+      return;
+    }
+
+    this.currentError = error;
+  }
+
+  getClassifiedErrorStructure(error) {
+    if (error instanceof Error) {
+      return {
+        code: ErrorCodes.UNKNOWN_ERROR,
+        message: error.message,
+        errorDetails: {
+          isBreaking: true,
+          originalError: error
+        }
+      };
+    } // if ((error as ErrorStructure).code) {
+
+
+    return error; // }
+    // return this.currentError;
+  }
+
+  getPublicErrorEvent(error) {
+    const payload = this.getClassifiedErrorStructure(error);
+    return this.constructAction({
+      type: `${this._name}${ERROR_OCCURRED_SUFFIX}`,
+      payload
+    });
+  }
+
   getName() {
     return this._name;
   }
@@ -55,10 +105,6 @@ export default class Component {
     return state;
   }
 
-  setProperties(properties) {
-    this._properties = properties;
-  }
-
   setEvents(_events) {
     this._events = _events;
   }
@@ -89,57 +135,10 @@ export default class Component {
 
   setBehaviours(behaviours) {
     this._behaviours = behaviours;
-    /* store behaviour properties */
-
-    this._behaviours.forEach(behaviour => {
-      behaviour.getProperties().data && behaviour.getProperties().data.forEach(obj => {
-        this._behavioursProperties[obj.getName()] = obj.clone();
-      });
-    });
   }
 
-  updateProperties(jsonValidator, newProps, schemaValidator) {
-    const entries = Object.fromEntries(this._properties.data.entries());
-    let property = entries === undefined ? {} : entries;
-    let propertyValue = newProps === undefined ? {} : newProps;
-
-    let isBhvrErrorVisible = this._properties.validateRequiredProperty(schemaValidator, this._behavioursProperties, propertyValue);
-
-    let isCompErrorVisible = this._properties.validateRequiredProperty(schemaValidator, property, propertyValue);
-
-    let isChanged = false;
-    Object.keys(newProps).forEach(key => {
-      let property = null;
-
-      if (this._behavioursProperties[key]) {
-        property = this._behavioursProperties[key];
-      } else if (this._properties.findProperty(key)) {
-        property = this._properties.findProperty(key);
-      }
-
-      if (property) {
-        const optionalSchema = property.getTypeMetadata().schema;
-        const propertyValue = newProps[key] === undefined ? property.getDefaultValue() : newProps[key];
-
-        const isValid = this._properties.validateSingleProperty(jsonValidator, key, propertyValue, optionalSchema);
-
-        if (isValid) {
-          isChanged = property.updateValue(newProps[key]) || isChanged;
-        }
-        /* return isValid */
-
-      } else {
-        throw new Error(`props '${key}' not exist `);
-      }
-    });
-
-    if (isBhvrErrorVisible && isCompErrorVisible) {
-      throw "";
-    }
-    /* return this._properties.updateAllPropertiesValue(jsonValidator, newProps); */
-
-
-    return isChanged;
+  updateProperties(jsonValidator, newProps) {
+    return this.componentProperties.validateAndUpdateProperties(jsonValidator, newProps);
   }
 
   updateState(state) {
@@ -158,15 +157,9 @@ export default class Component {
     return allBehavioursInitialState;
   }
 
-  init(jsonValidator, newProps, schemaValidator) {
-    this.updateProperties(jsonValidator, newProps, schemaValidator);
-
-    const properties = this._properties.getAllPropertiesValue();
-
-    const behavioursProperties = this.getAllBehavioursPropertiesWithValue();
-    let allProperties = { ...properties,
-      ...behavioursProperties
-    };
+  init(jsonValidator, newProps) {
+    this.updateProperties(jsonValidator, newProps);
+    const allProperties = this.componentProperties.getAllPropertiesValue();
     const behaviours = this.getAllBehavioursInitialState(allProperties);
 
     const initialState = this._stateInitializer({
@@ -179,9 +172,7 @@ export default class Component {
   }
 
   getProperties() {
-    return { ...this._properties.getAllPropertiesValue(),
-      ...this.getAllBehavioursPropertiesWithValue()
-    };
+    return this.componentProperties.getAllPropertiesValue();
   }
 
   getEventHandlersWrapper() {
@@ -210,12 +201,27 @@ export default class Component {
         let eventHandler = new EventHandler(key, event => {
           let state = this.getHandlerState();
           let action = event.detail;
-          actionHandler({
-            action,
-            host: event.currentTarget,
-            state,
-            ...helpers
-          });
+
+          try {
+            actionHandler({
+              action,
+              host: event.currentTarget,
+              state,
+              ...helpers
+            });
+          } catch (e) {
+            const error = {
+              code: ErrorCodes.EVENT_HANDLER_FAILED,
+              message: 'Error occurred in event handler for event ' + key,
+              errorDetails: {
+                isBreaking: false,
+                eventName: key,
+                event: action,
+                originalError: e instanceof Error ? e : undefined
+              }
+            };
+            helpers.dispatch(this.getPublicErrorEvent(error));
+          }
         });
 
         if (!eventHandlerMap.has(key)) {
@@ -241,7 +247,7 @@ export default class Component {
   constructAction(input) {
     let action = { ...input,
       payload: { ...input.payload,
-        ...this._properties.getAppendToActionPayloadProperty()
+        ...this.componentProperties.getAppendToActionPayloadProperty()
       }
     };
     return action;

package/es/library/custom-component/domain/entities/Properties.js

@@ -8,7 +8,7 @@ export default class Properties {
     this.data = properties;
     this.data.set('appendToActionPayload', new Property(defaultAppendToActionPayload));
     this.data.set('getRef', new Property(getRefPropertySchema));
-    typeof properties.get("slotName") === "undefined" && this.data.set('slotName', new Property(defaultSlotNameAppend));
+    typeof properties.get('slotName') === 'undefined' && this.data.set('slotName', new Property(defaultSlotNameAppend));
   }
 
   getAllPropertiesValue() {
@@ -20,152 +20,25 @@ export default class Properties {
 
     return convertedObject;
   }
-  /* break value object*/
 
-
-  updateAllPropertiesValue(validator, propertyValue) {
-    // this.validateProperties(validator, propertyValue);
-    if (!this.isEqual(propertyValue)) {
-      let isChanged = false;
-      Object.keys(propertyValue).forEach(key => {
-        let property = this.findProperty(key);
-
-        if (property.getValue() == null || property.getValue() == undefined) {
-          // property.updateValue(propertyValue[key]);
-          isChanged = true;
-        } else if (property.getValue() != propertyValue[key]) {
-          // property.updateValue(propertyValue[key]);
-          isChanged = true;
-        }
-      });
-      return isChanged;
-    }
-
-    return false;
+  getAllPropertiesKeys() {
+    return Array.from(this.data.keys());
   }
 
-  isEqual(newProps) {
-    let isShallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-
-    if (isShallow) {
-      return this.shallowCompareWithNewObject(newProps);
-    }
-
-    return false;
+  findProperty(key) {
+    return this.data.get(key);
   }
 
-  validateProperties(validator, newProps) {
-    let errors = [];
-    Object.keys(newProps).forEach(key => {
-      this.validate(validator, key, newProps[key], errors);
+  getPropertiesClone() {
+    const clonedMap = {};
+    this.data.forEach(obj => {
+      clonedMap[obj.getName()] = obj.clone();
     });
-
-    if (errors.length > 0) {
-      this.handleValidationErrors(errors);
-    }
-
-    return true;
-  }
-
-  validate(validator, key, value, errors) {
-    if (!this.data.has(key)) {
-      throw new Error(this.componentName + ` props '${key}' not exist `);
-    }
-
-    let property = this.data.get(key);
-    let schema = property.getTypeMetadata().schema;
-    let isValid;
-
-    try {
-      isValid = validator(schema, value);
-    } catch (error) {
-      isValid = false;
-    }
-
-    if (!isValid) {
-      const error = {
-        key: key,
-        componentName: this.componentName,
-        value: value,
-        schema: schema
-      };
-      errors.push(error);
-    }
-  }
-
-  handleValidationErrors(errors) {
-    console.log('Property validation failed', this.componentName, errors);
-    throw new Error('Property validation failed');
-  }
-
-  getSchema(key, optionalSchema) {
-    if (optionalSchema) {
-      return optionalSchema;
-    }
-
-    return this.data.get(key).getTypeMetadata().schema;
-  }
-
-  validateRequiredProperty(validator, properties, newProps) {
-    let errorWarn = validator(properties, newProps);
-    let isErrorVisible = false;
-
-    if (errorWarn.warnings && errorWarn.warnings.length > 0) {
-      errorWarn.warnings.forEach(warning => {
-        console.warn(`%c Property Validation Warnings in %c ${this.componentName}%c :\n${warning}`, 'font-weight: initial', 'color: #FF6F61;font-weight: bold', 'color: #FFA500;font-weight: initial');
-      });
-    }
-
-    if (errorWarn.errors && errorWarn.errors.length > 0) {
-      console.error(`%c Property Validation Errors in %c ${this.componentName}%c :\n${errorWarn.errors.join('\n')}`, 'font-weight: initial', 'color: #FF6F61;font-weight: bold', 'color: #FFF;font-weight: initial');
-      isErrorVisible = true;
-    }
-
-    return isErrorVisible;
-  }
-
-  validateSingleProperty(validator, onePropKey, onePropValue, optionalSchema) {
-    let schema = this.getSchema(onePropKey, optionalSchema); // INFO: Validate the property adheres to its schema
-
-    const {
-      isValid,
-      errors
-    } = validator(schema, onePropValue);
-
-    if (!isValid) {
-      const error = {
-        key: onePropKey,
-        componentName: this.componentName,
-        value: onePropValue,
-        isValid,
-        errors,
-        schema: schema
-      };
-      console.error('Property validation failed', error);
-      throw new Error('Property validation failed');
-    }
-
-    return true;
-  }
-
-  findProperty(key) {
-    return this.data.get(key);
+    return clonedMap;
   }
 
   getAppendToActionPayloadProperty() {
     return this.data.get('appendToActionPayload').getValue();
   }
 
-  shallowCompareWithNewObject(obj1) {
-    const keys1 = Object.keys(obj1);
-
-    for (let key of keys1) {
-      if (!this.data.has(key) || obj1[key] !== this.data.get(key).getValue()) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
 }

package/es/library/custom-component/domain/entities/Property.js

@@ -1,3 +1,4 @@
+/* eslint-disable complexity */
 export default class Property {
   constructor(_ref) {
     let {
@@ -40,6 +41,34 @@ export default class Property {
     return isChanged;
   }
 
+  getSchemaForValidation(value) {
+    return {
+      required: this.required,
+      isValueProvided: value !== undefined,
+      defaultValue: this.defaultValue,
+      name: this.name,
+      schema: this.getTypeMetadata().schema
+    };
+  }
+
+  validateProperty(validator, value) {
+    const propertySchema = this.getSchemaForValidation(value);
+    const propertyValue = !propertySchema.isValueProvided ? this.getDefaultValue() : value;
+    const {
+      isValid,
+      errors,
+      warnings
+    } = validator(propertySchema, propertyValue);
+    return {
+      key: this.name,
+      isValid,
+      errors,
+      warnings,
+      schema: propertySchema,
+      value: propertyValue
+    };
+  }
+
   clone() {
     return new Property({
       name: this.name,