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

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IClientActionManager.ts

@@ -0,0 +1,32 @@
+import DataSourceMetaData from '@platform/zdata-source/domain/entities/interfaces/MetaData';
+import { BehaviourState } from './BehaviourState';
+import IClientAction from './IClientAction';
+import StrategyMeta from './StrategyMeta';
+import EventModel from './EventModel';
+import IPayload from './IPayload';
+import { PropsMeta } from './PropsMeta';
+import { ClientActionModel } from './ClientActionModel';
+import { IError } from './IError';
+
+export default interface IClientActionManager {
+  createDataSourceExecuteEvent(
+    props: PropsMeta,
+    actionName: string,
+    metaData: DataSourceMetaData
+  ): EventModel<{ props; actionName }, DataSourceMetaData>;
+  createFetchClientActionMeta(actionName: string, apiName: string, props): DataSourceMetaData;
+  createSuccessEvents(response: ClientActionModel[], metaData: StrategyMeta): EventModel<IPayload, StrategyMeta>[];
+  createNoContentEvents(metaData: StrategyMeta): EventModel<IPayload, StrategyMeta>[];
+  createFailureEvents(error: IError, metaData: StrategyMeta): EventModel<IPayload, StrategyMeta>[];
+
+  fetchingStarted(): void;
+  fetchingFinished(): void;
+  setClientActions(records: IClientAction[]): void;
+
+  isGetClientActionsApi(actionName: string): boolean;
+  isClientActionsFetching(): boolean;
+
+  isClientActionApiName(apiName: string): boolean;
+
+  toObject(): BehaviourState;
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IClientActions.ts

@@ -0,0 +1,13 @@
+import IClientAction from './IClientAction';
+import { ClientActionsModel } from './ClientActionsModel';
+import ClientAction from '../ClientAction';
+
+
+export default interface IClientActions {
+  setIsFetching(isFetching: boolean): void;
+  setClientActions(clientActions: IClientAction[]): void;
+  isClientActionsFetching(): boolean;
+  getClientActionsLength(): number;
+  getClientAction(id: string): ClientAction | null;
+  toObject(): ClientActionsModel;
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IError.ts

@@ -0,0 +1,3 @@
+
+
+export type IError = any;

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IEvent.ts

@@ -0,0 +1,11 @@
+
+import { IAction } from "./IAction";
+import { State } from "./State";
+
+
+export interface IEvent {
+    state: State;
+    updateState: Function;
+    action: IAction;
+    dispatch: Function;
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IEventMapping.ts

@@ -0,0 +1,7 @@
+import { EventMappingModel } from "./EventMappingModel";
+
+
+export default interface IEventMapping {
+    toObject(): EventMappingModel;
+    getId(): string;
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IEventMappings.ts

@@ -0,0 +1,6 @@
+import IEventMapping from "./IEventMapping";
+
+
+export default interface IEventMappings {
+    toArray(): IEventMapping[];
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IPayload.ts

@@ -0,0 +1,5 @@
+
+
+export default interface IPayload {
+    [x: string]: any
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/IUIComponentMapping.ts

@@ -0,0 +1,6 @@
+import { UIComponentMappingModel } from "./UIComponentMappingModel";
+
+export default interface IUIComponentMapping {
+    toObject(): UIComponentMappingModel;
+    getId(): string;
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/PayloadValueMappingModel.ts

@@ -0,0 +1,3 @@
+export type PayloadValueMappingModel = {
+    [key: string]: string | number | boolean | object;
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/PropsMeta.ts

@@ -0,0 +1,3 @@
+export type PropsMeta = {
+    [x: string]: string | number;
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/State.ts

@@ -0,0 +1,7 @@
+import { BehaviourState } from "./BehaviourState";
+
+export type State = {
+    behaviours: {
+        zclientAction: BehaviourState;
+    };
+};

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/StrategyMeta.ts

@@ -0,0 +1,5 @@
+import { PropsMeta } from "./PropsMeta";
+
+type StrategyMeta = { type?: string; actionName: string; apiName: string; props: PropsMeta; isAppend?: boolean };
+
+export default StrategyMeta;

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/SubMeta.ts

@@ -0,0 +1,3 @@
+import StrategyMeta from "./StrategyMeta";
+
+export type SubMeta = { type: string; metaData: StrategyMeta };

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/UIComponentMappingModel.ts

@@ -0,0 +1,11 @@
+import { ComponentPropertiesModel } from "./ComponentPropertiesModel";
+import { EventMappingModel } from "./EventMappingModel";
+
+export type UIComponentMappingModel = {
+    id: string;
+    name: string;
+    component: string;
+    propertiesValueMapping: ComponentPropertiesModel;
+    propertiesValueMappingMeta: ComponentPropertiesModel;
+    eventMappings: EventMappingModel[];
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/UserDetailsModel.ts

@@ -0,0 +1,6 @@
+export type UserDetailsModel = {
+    id: string;
+    firstName: string;
+    lastName: string;
+    photoURL: string;
+};

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

@@ -0,0 +1,57 @@
+import { HttpTemplates } from '@platform/data-source/dbc';
+import ZActionEventHandlers from '../../../bc/zclient-actions/EventHandlers';
+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 { EventHandler } from '@cc/component/EventHandlers';
+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: 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: HttpTemplates): ZActionEventHandlers {
+    const presenter: Presenter = new Presenter();
+    const repository: Repository = new Repository();
+    const dependencies: { presenter: Presenter; repository: Repository } = { presenter, repository };
+    const service: Service = new Service(dependencies);
+    const mountController: MountController = new MountController(apiDetails, service);
+    const clientActionControllerHandle: Record<string, EventHandler> = 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.ts

@@ -0,0 +1,14 @@
+import Behaviour from '@cc/component/Behaviour';
+import { HttpTemplates } from '../../../../data-source/dbc';
+import ActionsHandlersFactory from './ActionsHandlersFactory';
+
+export default class ClientActionsBehaviourFactory {
+  static create(apiDetails: HttpTemplates): Behaviour {
+    return {
+      name: 'zclientAction',
+      eventHandlers: ActionsHandlersFactory.create(apiDetails),
+      properties: {},
+      setInitialState: () => ({})
+    };
+  }
+}

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

@@ -0,0 +1,36 @@
+import { ActionViewGap } from "../../components/interfaces/ActionViewModel";
+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: ''
+  },
+  gap: {
+    required: false,
+    defaultValue: ActionViewGap.NONE,
+    typeMetadata: {
+      schema: {
+        type: 'string',
+        enum: Object.values(ActionViewGap)
+      }
+    }
+  }
+};

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

@@ -0,0 +1,52 @@
+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: ['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.ts

@@ -0,0 +1,15 @@
+import { EventHandlerParams } from '@cc/component/EventHandlers';
+import IController from '@cc/architecture/IController';
+import InitializeUseCase from '../../applications/usecases/InitializeUseCase';
+
+export default class MountController implements IController<EventHandlerParams> {
+  constructor(protected initializeUseCase: InitializeUseCase) {
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(input: EventHandlerParams) {
+    const { host, dispatch, state, updateState }: EventHandlerParams = input;
+    this.initializeUseCase.updateDependencies(host, state, dispatch, updateState);
+    this.initializeUseCase.execute();
+  }
+}

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

@@ -0,0 +1,20 @@
+import { EventHandlerParams } from '@cc/component/EventHandlers';
+import IController from '@cc/architecture/IController';
+import PropertiesChangeUseCase from '../../applications/usecases/PropertiesChangeUseCase';
+
+export default class PropertiesChangeController implements IController<EventHandlerParams> {
+  constructor(protected propertiesChangeUseCase: PropertiesChangeUseCase) {
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(input: EventHandlerParams) {
+    const { host, dispatch, state, action, updateState }: EventHandlerParams = 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.ts

@@ -0,0 +1,15 @@
+import { EventHandlerParams } from '@cc/component/EventHandlers';
+import IController from '@cc/architecture/IController';
+import DestroyUseCase from '../../applications/usecases/DestroyUseCase';
+
+export default class UnmountController implements IController<EventHandlerParams> {
+  constructor(protected destroyUseCase: DestroyUseCase) {
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(input: EventHandlerParams) {
+    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.ts

@@ -0,0 +1,32 @@
+import ActionViewModel from '../../../interfaces/ActionViewModel';
+import IRepository from '../../applications/interfaces/gateways/IRepository';
+import ActionEventMediatorEntity from '../../domain/entities/ActionEventMediatorEntity';
+
+import { IState } from '../../domain/entities/interfaces/IState';
+
+export default class Repository implements IRepository {
+  private element: HTMLElement | null;
+  private dispatch: Function;
+  private state: IState;
+
+  init(state: IState) {
+    this.state = state;
+  }
+
+  constructor() {
+    this.element = null;
+  }
+
+  updateDependencies(element: HTMLElement, state, dispatch: Function) {
+    this.element = element;
+    this.dispatch = dispatch;
+    this.state = state;
+  }
+
+  getActionEventMediator(): ActionEventMediatorEntity {
+    const { actions }: { actions: ActionViewModel[] } = this.state.properties;
+    const { handlers }: { handlers: object } = this.state;
+    const actionEventMediator: ActionEventMediatorEntity = new ActionEventMediatorEntity(handlers, actions, this.element, this.dispatch);
+    return actionEventMediator;
+  }
+}

package/es/platform/client-actions/components/action-event-mediator/adapters/presenters/Presenter.ts

@@ -0,0 +1,20 @@
+import IPresenter from "../../applications/interfaces/output/IPresenter";
+
+
+export default class Presenter implements IPresenter {
+  private updateState: Function;
+  private state: any;
+
+  updateDependencies(state: any, updateState: Function) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateActionEventMediator(newState): void {
+    this.state = {
+      ...this.state,
+      ...newState
+    };
+    this.updateState(this.state);
+  }
+}

package/es/platform/client-actions/components/action-event-mediator/applications/interfaces/UseCaseDependencies.ts

@@ -0,0 +1,4 @@
+import IRepository from './gateways/IRepository';
+import IPresenter from './output/IPresenter';
+
+export type UseCaseDependencies = { repository: IRepository; presenter: IPresenter };

package/es/platform/client-actions/components/action-event-mediator/applications/interfaces/gateways/IRepository.ts

@@ -0,0 +1,6 @@
+import ActionEventMediatorEntity from '../../../domain/entities/ActionEventMediatorEntity';
+
+export default interface IRepository {
+  updateDependencies(element: HTMLElement, state, dispatch: Function): void;
+  getActionEventMediator(): ActionEventMediatorEntity;
+}

package/es/platform/client-actions/components/action-event-mediator/applications/interfaces/input/PropertiesChangeUseCaseInputModel.ts

@@ -0,0 +1,8 @@
+import ActionViewModel from '../../../domain/entities/interfaces/ActionViewModel';
+
+type PropertiesChangeUseCaseInputModel = {
+  previousActions: ActionViewModel[];
+  currentActions: ActionViewModel[];
+};
+
+export default PropertiesChangeUseCaseInputModel;

package/es/platform/client-actions/components/action-event-mediator/applications/interfaces/output/IPresenter.ts

@@ -0,0 +1,4 @@
+export default interface IPresenter {
+  updateDependencies(state: any, updateState: Function): void;
+  updateActionEventMediator(state): void;
+}

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

@@ -0,0 +1,14 @@
+import IUseCase from '@cc/architecture/IUseCase';
+import { UseCaseDependencies } from '../interfaces/UseCaseDependencies';
+
+export abstract class AbstractUseCase<Input> implements IUseCase<Input> {
+  constructor(protected dependencies: UseCaseDependencies) { }
+
+  updateDependencies(element: HTMLElement, state, dispatch: Function, updateState: Function) {
+    const { repository, presenter } = this.dependencies;
+    repository.updateDependencies(element, state, dispatch);
+    presenter.updateDependencies(state, updateState);
+  }
+
+  abstract execute(input: Input): void;
+}

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

@@ -0,0 +1,12 @@
+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.ts

@@ -0,0 +1,12 @@
+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.ts

@@ -0,0 +1,14 @@
+import PropertiesChangeUseCaseInputModel from '../interfaces/input/PropertiesChangeUseCaseInputModel';
+import { AbstractUseCase } from './AbstractUseCase';
+
+export default class PropertiesChangeUseCase extends AbstractUseCase<PropertiesChangeUseCaseInputModel> {
+  execute(input: PropertiesChangeUseCaseInputModel) {
+    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.ts

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

package/es/platform/client-actions/components/action-event-mediator/domain/entities/interfaces/IActionLocation.ts

@@ -0,0 +1,8 @@
+import ActionViewModel from './ActionViewModel';
+
+export interface IActionEventMediator {
+  initialize(): void;
+  destroy(): void;
+  processActionsChange(previousActions: ActionViewModel[], currentActions: ActionViewModel[]): void;
+  toObject(): object;
+}

package/es/platform/client-actions/components/action-event-mediator/domain/entities/interfaces/IState.ts

@@ -0,0 +1,4 @@
+import ActionViewModel, { ActionViewGap } from "../../../../interfaces/ActionViewModel";
+
+
+export type IState = { properties: { actions: ActionViewModel[], renderComponentType: string, gap: ActionViewGap }; handlers: object }

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

@@ -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
+});