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

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/GetClientActionsStrategy.js

@@ -0,0 +1,44 @@
+import { CLIENTACTION_EXECUTE_FAILED, CLIENTACTION_EXECUTE_SUCCEEDED, CLIENTACTION_EXECUTE_SUCCEEDED_NO_CONTENT, SET_CLIENTACTIONS } from "../../../../bc/zclient-actions/Constants";
+export default class GetClientActionsStrategy {
+  createSuccessEvents(response, metaData) {
+    const events = [];
+    const clientActions = response;
+    events.push({
+      type: SET_CLIENTACTIONS,
+      payload: {
+        clientActions
+      }
+    });
+    events.push({
+      type: CLIENTACTION_EXECUTE_SUCCEEDED,
+      payload: {
+        clientActions
+      },
+      metaData
+    });
+    return events;
+  }
+
+  createNoContentEvents(metaData) {
+    const events = [];
+    events.push({
+      type: CLIENTACTION_EXECUTE_SUCCEEDED_NO_CONTENT,
+      payload: {},
+      metaData
+    });
+    return events;
+  }
+
+  createFailureEvents(error, metaData) {
+    const events = [];
+    events.push({
+      type: CLIENTACTION_EXECUTE_FAILED,
+      payload: {
+        error
+      },
+      metaData
+    });
+    return events;
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/UIComponentMapping.js

@@ -0,0 +1,41 @@
+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 EventMappings from "./EventMappings";
+export default class UIComponentMapping {
+  constructor(uiComponentMappingObj) {
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "component", void 0);
+
+    _defineProperty(this, "propertiesValueMapping", void 0);
+
+    _defineProperty(this, "propertiesValueMappingMeta", void 0);
+
+    _defineProperty(this, "eventMappings", void 0);
+
+    this.id = uiComponentMappingObj.id;
+    this.name = uiComponentMappingObj.name;
+    this.component = uiComponentMappingObj.component;
+    this.propertiesValueMapping = uiComponentMappingObj.propertiesValueMapping;
+    this.propertiesValueMappingMeta = uiComponentMappingObj.propertiesValueMapping;
+    this.eventMappings = new EventMappings(uiComponentMappingObj.eventMappings);
+  }
+
+  toObject() {
+    return {
+      id: this.id,
+      name: this.name,
+      component: this.component,
+      propertiesValueMapping: this.propertiesValueMapping,
+      propertiesValueMappingMeta: this.propertiesValueMappingMeta,
+      eventMappings: this.eventMappings.toArray().map(eventMapping => eventMapping.toObject())
+    };
+  }
+
+  getId() {
+    return this.id;
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/frameworks/ActionsHandlersFactory.js

@@ -0,0 +1,47 @@
+import MountController from "../adapters/controllers/MountController";
+import Presenter from "../adapters/presenters/Presenter";
+import Repository from "../adapters/gateways/Repository";
+import Service from "../adapters/gateways/Service";
+import ClientActionBehaviourExecutorController from "../adapters/controllers/ClientActionBehaviourExecutorController";
+import FailureController from "../adapters/controllers/FailureController";
+import SuccessController from "../adapters/controllers/SuccessController";
+import NoContentController from "../adapters/controllers/NoContentController";
+import SetClientActionsController from "../adapters/controllers/SetClientActionsController";
+import FetchStateStopController from "../adapters/controllers/FetchStateStopController";
+import { CLIENTACTION_BEHAVIOUR_EXECUTE, CLIENTACTION_EXECUTE_FAIL_CALLBACK, CLIENTACTION_EXECUTE_FAILED, CLIENTACTION_EXECUTE_SUCCEEDED, CLIENTACTION_EXECUTE_SUCCEEDED_NO_CONTENT, CLIENTACTION_EXECUTE_SUCCESS_CALLBACK, SET_CLIENTACTIONS, CLIENTACTION_EXECUTE_SUCCESS_NO_CONTENT_CALLBACK } from "../../../bc/zclient-actions/Constants";
+export default class ActionsHandlersFactory {
+  static getClientActionControllerHandles(service) {
+    return {
+      executeClientActionBehaviour: new ClientActionBehaviourExecutorController(service).handle,
+      failure: new FailureController(service).handle,
+      success: new SuccessController(service).handle,
+      noContent: new NoContentController(service).handle,
+      setClientActions: new SetClientActionsController(service).handle,
+      fetchStateStop: new FetchStateStopController(service).handle
+    };
+  }
+
+  static create(apiDetails) {
+    const presenter = new Presenter();
+    const repository = new Repository();
+    const dependencies = {
+      presenter,
+      repository
+    };
+    const service = new Service(dependencies);
+    const mountController = new MountController(apiDetails, service);
+    const clientActionControllerHandle = ActionsHandlersFactory.getClientActionControllerHandles(service);
+    return {
+      MOUNT: mountController.handle,
+      [CLIENTACTION_BEHAVIOUR_EXECUTE]: clientActionControllerHandle.executeClientActionBehaviour,
+      [CLIENTACTION_EXECUTE_FAIL_CALLBACK]: clientActionControllerHandle.failure,
+      [CLIENTACTION_EXECUTE_SUCCESS_CALLBACK]: clientActionControllerHandle.success,
+      [CLIENTACTION_EXECUTE_SUCCEEDED]: clientActionControllerHandle.fetchStateStop,
+      [CLIENTACTION_EXECUTE_FAILED]: clientActionControllerHandle.fetchStateStop,
+      [CLIENTACTION_EXECUTE_SUCCEEDED_NO_CONTENT]: clientActionControllerHandle.fetchStateStop,
+      [SET_CLIENTACTIONS]: clientActionControllerHandle.setClientActions,
+      [CLIENTACTION_EXECUTE_SUCCESS_NO_CONTENT_CALLBACK]: clientActionControllerHandle.noContent
+    };
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/frameworks/ClientActionsBehaviourFactory.js

@@ -0,0 +1,12 @@
+import ActionsHandlersFactory from "./ActionsHandlersFactory";
+export default class ClientActionsBehaviourFactory {
+  static create(apiDetails) {
+    return {
+      name: 'zclientAction',
+      eventHandlers: ActionsHandlersFactory.create(apiDetails),
+      properties: {},
+      setInitialState: () => ({})
+    };
+  }
+
+}

package/es/platform/client-actions/cc/action-event-mediator/Properties.js

@@ -0,0 +1,23 @@
+import { actionSchema } from "../dynamic-action-component/Properties";
+export const actionsSchema = {
+  type: 'array',
+  minItems: 0,
+  items: actionSchema
+};
+export default {
+  actions: {
+    required: true,
+    typeMetadata: {
+      schema: actionsSchema
+    }
+  },
+  renderComponentType: {
+    required: false,
+    typeMetadata: {
+      schema: {
+        type: 'string'
+      }
+    },
+    defaultValue: ''
+  }
+};

package/es/platform/client-actions/cc/dynamic-action-component/Properties.js

@@ -0,0 +1,51 @@
+export const actionSchema = {
+  type: 'object',
+  properties: {
+    component: {
+      type: 'string'
+    },
+    id: {
+      type: 'string'
+    },
+    properties: {
+      type: 'object'
+    },
+    eventMappings: {
+      type: 'array',
+      minItems: 0,
+      items: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'object',
+            properties: {
+              event: {
+                type: 'string'
+              },
+              payload: {
+                type: 'object'
+              }
+            },
+            required: ['event', 'payload']
+          },
+          id: {
+            type: 'string'
+          },
+          sourceEvent: {
+            type: 'string'
+          }
+        },
+        required: ['action', 'sourceEvent', 'id']
+      }
+    }
+  },
+  required: ['component', 'properties']
+};
+export default {
+  action: {
+    required: true,
+    typeMetadata: {
+      schema: actionSchema
+    }
+  }
+};

package/es/platform/client-actions/components/action-event-mediator/adapters/controllers/MountController.js

@@ -0,0 +1,18 @@
+export default class MountController {
+  constructor(initializeUseCase) {
+    this.initializeUseCase = initializeUseCase;
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(input) {
+    const {
+      host,
+      dispatch,
+      state,
+      updateState
+    } = input;
+    this.initializeUseCase.updateDependencies(host, state, dispatch, updateState);
+    this.initializeUseCase.execute();
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/adapters/controllers/PropertiesChangeController.js

@@ -0,0 +1,26 @@
+export default class PropertiesChangeController {
+  constructor(propertiesChangeUseCase) {
+    this.propertiesChangeUseCase = propertiesChangeUseCase;
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(input) {
+    const {
+      host,
+      dispatch,
+      state,
+      action,
+      updateState
+    } = input;
+    const {
+      currentProperties,
+      previousProperties
+    } = action.payload;
+    this.propertiesChangeUseCase.updateDependencies(host, state, dispatch, updateState);
+    this.propertiesChangeUseCase.execute({
+      currentActions: currentProperties.actions,
+      previousActions: previousProperties.actions
+    });
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/adapters/controllers/UnmountController.js

@@ -0,0 +1,18 @@
+export default class UnmountController {
+  constructor(destroyUseCase) {
+    this.destroyUseCase = destroyUseCase;
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(input) {
+    const {
+      host,
+      dispatch,
+      state,
+      updateState
+    } = input;
+    this.destroyUseCase.updateDependencies(host, state, dispatch, updateState);
+    this.destroyUseCase.execute();
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/adapters/gateway/Repository.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; }
+
+import ActionEventMediatorEntity from "../../domain/entities/ActionEventMediatorEntity";
+export default class Repository {
+  init(state) {
+    this.state = state;
+  }
+
+  constructor() {
+    _defineProperty(this, "element", void 0);
+
+    _defineProperty(this, "dispatch", void 0);
+
+    _defineProperty(this, "state", void 0);
+
+    this.element = null;
+  }
+
+  updateDependencies(element, state, dispatch) {
+    this.element = element;
+    this.dispatch = dispatch;
+    this.state = state;
+  }
+
+  getActionEventMediator() {
+    const {
+      actions
+    } = this.state.properties;
+    const {
+      handlers
+    } = this.state;
+    const actionEventMediator = new ActionEventMediatorEntity(handlers, actions, this.element, this.dispatch);
+    return actionEventMediator;
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/adapters/presenters/Presenter.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 Presenter {
+  constructor() {
+    _defineProperty(this, "updateState", void 0);
+
+    _defineProperty(this, "state", void 0);
+  }
+
+  updateDependencies(state, updateState) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateActionEventMediator(newState) {
+    this.state = { ...this.state,
+      ...newState
+    };
+    this.updateState(this.state);
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/AbstractUseCase.js

@@ -0,0 +1,15 @@
+export class AbstractUseCase {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+
+  updateDependencies(element, state, dispatch, updateState) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    repository.updateDependencies(element, state, dispatch);
+    presenter.updateDependencies(state, updateState);
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/DestroyUseCase.js

@@ -0,0 +1,13 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class DestroyUseCase extends AbstractUseCase {
+  execute() {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const actionLocation = repository.getActionEventMediator();
+    actionLocation.destroy();
+    presenter.updateActionEventMediator(actionLocation.toObject());
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/InitializeUseCase.js

@@ -0,0 +1,13 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class InitializeUseCase extends AbstractUseCase {
+  execute() {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const actionLocation = repository.getActionEventMediator();
+    actionLocation.initialize();
+    presenter.updateActionEventMediator(actionLocation.toObject());
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/PropertiesChangeUseCase.js

@@ -0,0 +1,17 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class PropertiesChangeUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const actionLocation = repository.getActionEventMediator();
+    const {
+      currentActions,
+      previousActions
+    } = input;
+    actionLocation.processActionsChange(currentActions, previousActions);
+    presenter.updateActionEventMediator(actionLocation.toObject());
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/domain/entities/ActionEventMediatorEntity.js

@@ -0,0 +1,108 @@
+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 TemplateResolver from "../../../../template-resolver";
+export default class ActionEventMediatorEntity {
+  constructor(handlers, actions, element, dispatch) {
+    this.handlers = handlers;
+    this.actions = actions;
+    this.element = element;
+    this.dispatch = dispatch;
+
+    _defineProperty(this, "contextResolver", void 0);
+  }
+
+  createEventHandlers(event) {
+    // TODO: this code needs to move to custom component or somewhere else
+    return e => {
+      const {
+        eventMappings,
+        ...payloadItems
+      } = e.detail.payload;
+      const eventMapping = eventMappings.find(eventMapping => eventMapping.sourceEvent === event);
+
+      if (!eventMapping) {
+        return;
+      }
+
+      const dispatchEvent = eventMapping.targetEvent;
+      const payload = eventMapping.payload;
+      const replacementContext = {
+        "@payload": payloadItems
+      };
+      const resolvedPayload = TemplateResolver.replaceContextVariablesInObject(payload, replacementContext);
+      this.dispatch({
+        type: dispatchEvent,
+        payload: resolvedPayload
+      });
+    };
+  }
+
+  getEventNames(actions) {
+    const eventNames = [];
+    actions.forEach(action => {
+      action.eventMappings.forEach(eventMapping => {
+        if (!eventNames.includes(eventMapping.sourceEvent)) {
+          eventNames.push(eventMapping.sourceEvent);
+        }
+      });
+    });
+    return eventNames;
+  }
+
+  listen(eventName) {
+    var _this$element;
+
+    const handler = this.createEventHandlers(eventName);
+    this.handlers[eventName] = handler;
+    (_this$element = this.element) === null || _this$element === void 0 ? void 0 : _this$element.addEventListener(eventName, handler);
+  }
+
+  unListen(eventName) {
+    var _this$element2;
+
+    const handler = this.handlers[eventName];
+    (_this$element2 = this.element) === null || _this$element2 === void 0 ? void 0 : _this$element2.removeEventListener(eventName, handler);
+    this.handlers[eventName] = undefined;
+  }
+
+  compareEventNames(previousEventNames, currentEventNames) {
+    return previousEventNames.length === currentEventNames.length && previousEventNames.every((eventName, index) => eventName === currentEventNames[index]);
+  }
+
+  initialize() {
+    const eventNames = this.getEventNames(this.actions);
+    eventNames.forEach(eventName => {
+      this.listen(eventName);
+    });
+  }
+
+  processActionsChange(previousActions, currentActions) {
+    const previousEventNames = this.getEventNames(previousActions).sort();
+    const currentEventNames = this.getEventNames(currentActions).sort();
+
+    if (this.compareEventNames(previousEventNames, currentEventNames)) {
+      return;
+    }
+
+    previousEventNames.forEach(eventName => {
+      this.unListen(eventName);
+    });
+    currentEventNames.forEach(eventName => {
+      this.listen(eventName);
+    });
+  }
+
+  destroy() {
+    const eventNames = this.getEventNames(this.actions);
+    eventNames.forEach(eventName => {
+      this.unListen(eventName);
+    });
+  }
+
+  toObject() {
+    return {
+      handlers: this.handlers
+    };
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/frameworks/ui/ActionEventMediator.js

@@ -0,0 +1,13 @@
+import { createCustomComponent } from "../../../../../../library/custom-component";
+import ActionEventMediatorProperties from "../../../../cc/action-event-mediator/Properties";
+import EventHandlersFactory from "./EventHandlersFactory";
+import ActionEventMediatorView from "./ActionEventMediatorView";
+export default createCustomComponent({
+  name: 'ActionEventMediator',
+  properties: ActionEventMediatorProperties,
+  setInitialState: () => ({
+    handlers: {}
+  }),
+  eventHandlers: EventHandlersFactory.create(),
+  View: ActionEventMediatorView
+});

package/es/platform/client-actions/components/action-event-mediator/frameworks/ui/ActionEventMediatorView.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import RowActionsRenderer from "../../../row-actions-renderer/frameworks/ui/RowActionsRenderer";
+import { ComponentRegistry } from "../../../../../../library";
+export default function ActionEventMediatorView(_ref, ref) {
+  let {
+    state
+  } = _ref;
+  const {
+    actions,
+    renderComponentType
+  } = state.properties;
+  const ActionRenderComponent = ComponentRegistry.get(renderComponentType) || RowActionsRenderer;
+  return /*#__PURE__*/React.createElement(ActionRenderComponent, {
+    actions: actions,
+    getRef: ref
+  });
+}

package/es/platform/client-actions/components/action-event-mediator/frameworks/ui/EventHandlersFactory.js

@@ -0,0 +1,30 @@
+import Repository from "../../adapters/gateway/Repository";
+import Presenter from "../../adapters/presenters/Presenter";
+import InitializeUseCase from "../../applications/usecases/InitializeUseCase";
+import DestroyUseCase from "../../applications/usecases/DestroyUseCase";
+import PropertiesChangeUseCase from "../../applications/usecases/PropertiesChangeUseCase";
+import MountController from "../../adapters/controllers/MountController";
+import UnmountController from "../../adapters/controllers/UnmountController";
+import PropertiesChangeController from "../../adapters/controllers/PropertiesChangeController";
+export default class EventHandlersFactory {
+  static create() {
+    const repository = new Repository();
+    const presenter = new Presenter();
+    const dependencies = {
+      repository,
+      presenter
+    };
+    const initializeUseCase = new InitializeUseCase(dependencies);
+    const destroyUseCase = new DestroyUseCase(dependencies);
+    const propertiesChangeUseCase = new PropertiesChangeUseCase(dependencies);
+    const initializeController = new MountController(initializeUseCase);
+    const unmountController = new UnmountController(destroyUseCase);
+    const propertiesChangeController = new PropertiesChangeController(propertiesChangeUseCase);
+    return {
+      MOUNT: initializeController.handle,
+      UPDATE_PROPERTIES: propertiesChangeController.handle,
+      UNMOUNT: unmountController.handle
+    };
+  }
+
+}

package/es/platform/client-actions/components/dynamic-component/frameworks/ui/DynamicActionComponent.js

@@ -0,0 +1,9 @@
+import { createCustomComponent } from "../../../../../../library/custom-component";
+import DynamicActionComponentProperties from "../../../../cc/dynamic-action-component/Properties";
+import DynamicActionComponentView from "./DynamicActionComponentView";
+export default createCustomComponent({
+  name: 'DynamicActionComponent',
+  properties: DynamicActionComponentProperties,
+  eventHandlers: {},
+  View: DynamicActionComponentView
+});

package/es/platform/client-actions/components/dynamic-component/frameworks/ui/DynamicActionComponentView.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import ComponentRegistry from "../../../../../../library/custom-component/frameworks/ui/ComponentRegistry";
+
+function DynamicComponentView(_ref, ref) {
+  let {
+    state
+  } = _ref;
+  const {
+    action
+  } = state.properties;
+  const {
+    component,
+    properties,
+    eventMappings
+  } = action;
+  const Component = ComponentRegistry.get(component);
+
+  if (!Component) {
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    }, "Error");
+  }
+
+  return /*#__PURE__*/React.createElement(Component, {
+    getRef: ref,
+    ...properties,
+    appendToActionPayload: {
+      eventMappings
+    }
+  });
+}
+
+;
+export default DynamicComponentView;

package/es/platform/client-actions/components/row-actions-renderer/frameworks/ui/RowActionsRenderer.js

@@ -0,0 +1,12 @@
+import { createCustomComponent } from "../../../../../../library/custom-component";
+import RowActionsRendererProperties from "../../../../cc/action-event-mediator/Properties";
+import RowActionsRendererView from "./RowActionsRendererView";
+import { ComponentRegistry } from "../../../../../../library";
+const RowActionsRendererComponent = createCustomComponent({
+  name: 'RowActionsRenderer',
+  properties: RowActionsRendererProperties,
+  eventHandlers: {},
+  View: RowActionsRendererView
+});
+ComponentRegistry.register("RowActionsRenderer", RowActionsRendererComponent);
+export default RowActionsRendererComponent;