@zohodesk/library-platform 1.0.1 → 1.0.2-exp.1.1

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

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

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

@@ -0,0 +1,29 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class UpdatePropertyUseCase extends AbstractUseCase {
+  execute(newProps) {
+    let {
+      repository,
+      jsonValidator,
+      eventManager,
+      presenter
+    } = this.dependencies;
+    let component = repository.getComponent();
+    let properties = component.getProperties();
+    let isUpdated = component.updateProperties(jsonValidator, newProps);
+
+    if (isUpdated) {
+      let updatedProperties = component.getProperties();
+      let state = component.getState();
+      presenter.render(state);
+      let updatePropertyAction = component.getPropertyUpdateAction({
+        currentProperties: updatedProperties,
+        previousProperties: properties
+      });
+      eventManager.dispatch(updatePropertyAction);
+    }
+  }
+
+}
+
+export default UpdatePropertyUseCase;

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

@@ -0,0 +1,20 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class UpdateStateUseCase extends AbstractUseCase {
+  execute(newState) {
+    let {
+      repository,
+      presenter
+    } = this.dependencies;
+    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);
+  }
+
+}
+
+export default UpdateStateUseCase;

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

@@ -0,0 +1,54 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class Behaviour {
+  constructor(_ref) {
+    let {
+      name,
+      properties,
+      setIntialState,
+      eventHandlers
+    } = _ref;
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "properties", void 0);
+
+    _defineProperty(this, "setIntialState", void 0);
+
+    _defineProperty(this, "eventHandlers", void 0);
+
+    this.name = name;
+    this.properties = properties;
+    this.setIntialState = setIntialState;
+    this.eventHandlers = eventHandlers;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getProperties() {
+    return this.properties;
+  }
+
+  getEventHandlers() {
+    return this.eventHandlers;
+  }
+
+  getInitialState(propertiesValues) {
+    if (this.setIntialState) {
+      return {
+        [this.name]: this.setIntialState({
+          properties: propertiesValues
+        })
+      };
+    } else {
+      return {
+        [this.name]: {}
+      };
+    }
+  }
+
+}
+
+export default Behaviour;

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

@@ -0,0 +1,257 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import EventHandler from "./EventHandler";
+export default class Component {
+  constructor() {
+    _defineProperty(this, "_name", void 0);
+
+    _defineProperty(this, "_events", void 0);
+
+    _defineProperty(this, "_properties", void 0);
+
+    _defineProperty(this, "_lifeCycleAction", void 0);
+
+    _defineProperty(this, "_eventHandlers", void 0);
+
+    _defineProperty(this, "_tranformer", void 0);
+
+    _defineProperty(this, "_stateInitializer", void 0);
+
+    _defineProperty(this, "_state", void 0);
+
+    _defineProperty(this, "_eventHandlersWrapper", void 0);
+
+    _defineProperty(this, "_behaviours", void 0);
+
+    _defineProperty(this, "_behavioursProperties", void 0);
+
+    this._behavioursProperties = {};
+  }
+
+  getAllBehavioursPropertiesWithValue() {
+    let output = {};
+    Object.keys(this._behavioursProperties).forEach((value, key) => {
+      output[value] = this._behavioursProperties[value].getValue();
+    });
+    return output;
+  }
+
+  mergeStateAndProps() {
+    return { ...this._state.getState(),
+      properties: { ...this._properties.getAllPropertiesValue(),
+        ...this.getAllBehavioursPropertiesWithValue()
+      }
+    };
+  }
+
+  getName() {
+    return this._name;
+  }
+
+  getEventHandlers() {
+    return this._eventHandlers.getEventHandlers();
+  }
+
+  getMountAction() {
+    return this._lifeCycleAction.getMountAction();
+  }
+
+  getUnmountAction() {
+    return this._lifeCycleAction.getUnmountAction();
+  }
+
+  getPropertyUpdateAction(payload) {
+    return this._lifeCycleAction.getUpdatePropertiesAction(payload);
+  }
+
+  getState() {
+    let state = this._tranformer(this.mergeStateAndProps());
+
+    return state;
+  }
+
+  getHandlerState() {
+    let state = this.mergeStateAndProps();
+    return state;
+  }
+
+  setProperties(properties) {
+    this._properties = properties;
+  }
+
+  setEvents(_events) {
+    this._events = _events;
+  }
+
+  setLifeCycleAction(lifeCycleAction) {
+    this._lifeCycleAction = lifeCycleAction;
+  }
+
+  setEventHandlers(eventHandlers) {
+    this._eventHandlers = eventHandlers;
+  }
+
+  setName(name) {
+    this._name = name;
+  }
+
+  setTransformer(transformer) {
+    this._tranformer = transformer;
+  }
+
+  setState(state) {
+    this._state = state;
+  }
+
+  setStateInitializer(_stateInitializer) {
+    this._stateInitializer = typeof _stateInitializer !== 'function' ? input => input : _stateInitializer;
+  }
+
+  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) {
+    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 `);
+      }
+    });
+    /* return this._properties.updateAllPropertiesValue(jsonValidator, newProps); */
+
+    return isChanged;
+  }
+
+  updateState(state) {
+    this._state.updateState(state);
+  }
+
+  getAllBehavioursInitialState(propertiesValues) {
+    let allBehavioursInitialState = {};
+
+    this._behaviours.map(behaviour => {
+      allBehavioursInitialState = { ...allBehavioursInitialState,
+        ...behaviour.getInitialState(propertiesValues)
+      };
+    });
+
+    return allBehavioursInitialState;
+  }
+
+  init(jsonValidator, newProps) {
+    this.updateProperties(jsonValidator, newProps);
+
+    const properties = this._properties.getAllPropertiesValue();
+
+    const behavioursProperties = this.getAllBehavioursPropertiesWithValue();
+    let allProperties = { ...properties,
+      ...behavioursProperties
+    };
+    const behaviours = this.getAllBehavioursInitialState(allProperties);
+
+    const initialState = this._stateInitializer({
+      properties: allProperties
+    });
+
+    this.updateState({ ...initialState,
+      behaviours
+    });
+  }
+
+  getProperties() {
+    return { ...this._properties.getAllPropertiesValue(),
+      ...this.getAllBehavioursPropertiesWithValue()
+    };
+  }
+
+  getEventHandlersWrapper() {
+    let boundEventHandlers = new Map();
+
+    this._eventHandlersWrapper.forEach((handlers, key) => {
+      let handlersFunction = handlers.map(handler => {
+        return handler.getEventHandler();
+      });
+      boundEventHandlers.set(key, handlersFunction);
+    });
+
+    return boundEventHandlers;
+  }
+  /* eslint-disable max-lines-per-function */
+  // TODO: Refactor this function to reduce the number of lines
+
+
+  createEventHandlers(helpers) {
+    let eventHandlers = this._eventHandlers.getEventHandlers();
+
+    this._eventHandlersWrapper = new Map();
+
+    let createActionToEventHandler = (eventHandlers, eventHandlerMap) => {
+      eventHandlers.forEach((actionHandler, key) => {
+        let eventHandler = new EventHandler(key, event => {
+          let state = this.getHandlerState();
+          let action = event.detail;
+          actionHandler({
+            action,
+            host: event.currentTarget,
+            state,
+            ...helpers
+          });
+        });
+
+        if (!eventHandlerMap.has(key)) {
+          let newHandlersArray = [];
+          newHandlersArray.push(eventHandler);
+          eventHandlerMap.set(key, newHandlersArray);
+        } else {
+          let existingHandlers = eventHandlerMap.get(key);
+          existingHandlers.push(eventHandler);
+          eventHandlerMap.set(key, existingHandlers);
+        }
+      });
+    };
+
+    createActionToEventHandler(eventHandlers, this._eventHandlersWrapper);
+
+    this._behaviours.forEach(behaviour => {
+      let eventHandlers = behaviour.getEventHandlers().getEventHandlers();
+      createActionToEventHandler(eventHandlers, this._eventHandlersWrapper);
+    });
+  }
+
+  constructAction(input) {
+    let action = { ...input,
+      payload: { ...input.payload,
+        ...this._properties.getAppendToActionPayloadProperty()
+      }
+    };
+    return action;
+  }
+
+}

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

@@ -0,0 +1,10 @@
+export default {
+  name: 'appendToActionPayload',
+  required: false,
+  defaultValue: null,
+  typeMetadata: {
+    schema: {
+      type: 'object'
+    }
+  }
+};

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

@@ -0,0 +1,32 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class Event {
+  constructor(type) {
+    let payload = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    _defineProperty(this, "type", void 0);
+
+    _defineProperty(this, "payload", void 0);
+
+    this.type = type;
+    this.payload = payload;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getPayload() {
+    return this.payload;
+  }
+
+  toObject() {
+    return {
+      type: this.type,
+      payload: this.payload
+    };
+  }
+
+}
+
+export default Event;

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

@@ -0,0 +1,156 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import Property from "./Property";
+import defaultAppendToActionPayload from "./DefaultAppendToActionPayload";
+import getRefPropertySchema from "../../../../cc/component/properties/getRefPropertySchema";
+export default class Properties {
+  constructor(properties, componentName) {
+    this.componentName = componentName;
+
+    _defineProperty(this, "data", void 0);
+
+    this.data = properties;
+    this.data.set('appendToActionPayload', new Property(defaultAppendToActionPayload));
+    this.data.set('getRef', new Property(getRefPropertySchema));
+  }
+
+  getAllPropertiesValue() {
+    const convertedObject = {};
+
+    for (const [key, value] of this.data.entries()) {
+      convertedObject[key] = value.getValue();
+    }
+
+    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;
+  }
+
+  isEqual(newProps) {
+    let isShallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+    if (isShallow) {
+      return this.shallowCompareWithNewObject(newProps);
+    }
+
+    return false;
+  }
+
+  validateProperties(validator, newProps) {
+    let errors = [];
+    Object.keys(newProps).forEach(key => {
+      this.validate(validator, key, newProps[key], errors);
+    });
+
+    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;
+  }
+
+  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.log('Property validation failed', error);
+      throw new Error('Property validation failed');
+    }
+
+    return true;
+  }
+
+  findProperty(key) {
+    return this.data.get(key);
+  }
+
+  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

@@ -0,0 +1,65 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+export default class Property {
+  constructor(_ref) {
+    let {
+      name,
+      defaultValue,
+      required,
+      typeMetadata
+    } = _ref;
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "required", void 0);
+
+    _defineProperty(this, "defaultValue", void 0);
+
+    _defineProperty(this, "typeMetadata", void 0);
+
+    _defineProperty(this, "value", void 0);
+
+    this.name = name;
+    this.defaultValue = defaultValue;
+    this.required = required;
+    this.typeMetadata = typeMetadata;
+  }
+
+  getRequired() {
+    return this.required;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getDefaultValue() {
+    return this.defaultValue;
+  }
+
+  getTypeMetadata() {
+    return this.typeMetadata;
+  }
+
+  getValue() {
+    return this.value == undefined ? this.defaultValue : this.value;
+  }
+  /* break value object*/
+
+
+  updateValue(value) {
+    const isChanged = this.value !== value;
+    this.value = value;
+    return isChanged;
+  }
+
+  clone() {
+    return new Property({
+      name: this.name,
+      defaultValue: this.defaultValue,
+      required: this.required,
+      typeMetadata: this.typeMetadata
+    });
+  }
+
+}

package/es/library/custom-component/frameworks/json-schema-validator/Validator.js

@@ -3,11 +3,27 @@ let jsonValidator = new Ajv();
 
 class Validator {
   static validate(schema, value) {
-    if (schema.type === "function" && typeof value === "function") {
-      return true;
+    let errors = [];
+
+    if (schema.type === 'function' && typeof value === 'function') {
+      return {
+        isValid: true,
+        errors
+      };
+    } // validate is a type guard for MyData - type is inferred from schema type
+
+
+    const validate = jsonValidator.compile(schema);
+    const isValid = validate(value);
+
+    if (!isValid) {
+      errors = validate.errors;
     }
 
-    return jsonValidator.validate(schema, value);
+    return {
+      isValid,
+      errors
+    };
   }
 
 }