@zohodesk/library-platform 1.0.2-exp.1.0 → 1.0.2-exp.1.2

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/EventHandler.js

@@ -0,0 +1,17 @@
+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 EventHandler {
+  constructor(key, handler) {
+    _defineProperty(this, "handler", void 0);
+
+    _defineProperty(this, "key", void 0);
+
+    this.key = key;
+    this.handler = handler;
+  }
+
+  getEventHandler() {
+    return this.handler;
+  }
+
+}

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

@@ -0,0 +1,12 @@
+class EventHandlers {
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+
+  getEventHandlers() {
+    return this.handlers;
+  }
+
+}
+
+export default EventHandlers;

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

@@ -0,0 +1,38 @@
+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 LifeCycleAction {
+  constructor(name) {
+    _defineProperty(this, "mount", void 0);
+
+    _defineProperty(this, "unmount", void 0);
+
+    _defineProperty(this, "contructUpdatePropertiesAction", void 0);
+
+    this.mount = {
+      type: `${name}#MOUNT`
+    };
+    this.unmount = {
+      type: `${name}#UN_MOUNT`
+    };
+
+    this.contructUpdatePropertiesAction = payload => {
+      return {
+        type: `${name}#UPDATE_PROPERTIES`,
+        payload
+      };
+    };
+  }
+
+  getMountAction() {
+    return this.mount;
+  }
+
+  getUnmountAction() {
+    return this.unmount;
+  }
+
+  getUpdatePropertiesAction(payload) {
+    return this.contructUpdatePropertiesAction(payload);
+  }
+
+}

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

@@ -0,0 +1,21 @@
+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 Payload {
+  constructor(name, typeMetadata) {
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "typeMetadata", void 0);
+
+    this.name = name;
+    this.typeMetadata = typeMetadata;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getTypeMetadata() {
+    return this.typeMetadata;
+  }
+
+}

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/domain/entities/Schema.js

@@ -0,0 +1,14 @@
+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 Schema {
+  constructor() {
+    _defineProperty(this, "_type", void 0);
+  }
+
+  getType() {
+    return this._type;
+  }
+
+}
+
+export default Schema;

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

@@ -0,0 +1,22 @@
+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 State {
+  constructor() {
+    _defineProperty(this, "state", void 0);
+
+    this.state = {};
+  }
+
+  getState() {
+    return this.state;
+  }
+  /* break value object*/
+
+
+  updateState(state) {
+    this.state = { ...this.state,
+      ...state
+    };
+  }
+
+}

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

@@ -0,0 +1,36 @@
+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 Style {
+  constructor() {
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "label", void 0);
+
+    _defineProperty(this, "required", void 0);
+
+    _defineProperty(this, "defaultValue", void 0);
+
+    _defineProperty(this, "typeMetadata", void 0);
+  }
+
+  getLabel() {
+    return this.label;
+  }
+
+  getRequired() {
+    return this.required;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getDefaultValue() {
+    return this.defaultValue;
+  }
+
+  getTypeMetadata() {
+    return this.typeMetadata;
+  }
+
+}

package/es/library/custom-component/domain/entities/interfaces/EventModel.js

@@ -0,0 +1 @@
+export {};

package/es/library/custom-component/domain/entities/interfaces/IBehaviour.js

@@ -0,0 +1 @@
+export {};

package/es/library/custom-component/domain/entities/interfaces/IComponent.js

@@ -0,0 +1 @@
+export {};

package/es/library/custom-component/domain/entities/interfaces/IEvent.js

@@ -0,0 +1 @@
+export {};

package/es/library/custom-component/domain/entities/interfaces/IEventHandler.js

@@ -0,0 +1 @@
+export {};