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

package/es/library/behaviours/sort-by/adapters/controllers/AbstractController.ts

@@ -0,0 +1,11 @@
+import IService from '../../applications/interfaces/gateways/IService';
+
+abstract class AbstractController {
+  constructor(protected service: IService) {
+    this.handle = this.handle.bind(this);
+  }
+
+  abstract handle(event): void;
+}
+
+export default AbstractController;

package/es/library/behaviours/sort-by/adapters/controllers/SortBy.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class SortByController extends AbstractController {
+  handle(event) {
+    const { sortByUseCase } = this.service;
+    let { state, updateState, action, dispatch } = event;
+    let { id, name } = action.payload;
+
+    sortByUseCase.updateDependencies(state, updateState);
+    sortByUseCase.execute({ id, name, dispatch });
+  }
+}
+
+export default SortByController;

package/es/library/behaviours/sort-by/adapters/gateway/Repository.ts

@@ -0,0 +1,17 @@
+import ISortBy from '../../domain/entities/interfaces/ISortBy';
+import SortBy from '../../domain/entities/SortBy';
+import IRepository from '../../applications/interfaces/gateways/IRepository';
+
+export default class Repository implements IRepository {
+  private state: any;
+
+  init(state: any) {
+    this.state = state;
+  }
+
+  getSortByEntity(): ISortBy {
+    const { behaviours } = this.state;
+    const { id, name, order } = behaviours.sortBy;
+    return new SortBy(id, name, order);
+  }
+}

package/es/library/behaviours/sort-by/adapters/gateway/Service.ts

@@ -0,0 +1,13 @@
+import SortBy from '../../applications/usecases/SortBy';
+import IService from '../../applications/interfaces/gateways/IService';
+import UseCaseDependencies from '../../applications/interfaces/UseCaseDependencies';
+
+class Service implements IService {
+  sortByUseCase: SortBy;
+
+  constructor(dependencies: UseCaseDependencies) {
+    this.sortByUseCase = new SortBy(dependencies);
+  }
+}
+
+export default Service;

package/es/library/behaviours/sort-by/adapters/presenter/Presenter.ts

@@ -0,0 +1,23 @@
+import { IPresenter } from '../../applications/interfaces/output/IPresenter';
+import SortByOutputModel from '../../applications/interfaces/output/SortByOutputModel';
+
+export default class Presenter implements IPresenter {
+  private updateState: Function;
+  private state: any;
+
+  updateDependencies(state: any, updateState: Function) {
+    this.state = state;
+    this.updateState = updateState;
+  }
+
+  updateSortBy(sortBy: SortByOutputModel): void {
+    this.state = {
+      ...this.state,
+      behaviours: {
+        ...this.state.behaviours,
+        sortBy
+      }
+    };
+    this.updateState(this.state);
+  }
+}

package/es/library/behaviours/sort-by/applications/interfaces/UseCaseDependencies.ts

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

package/es/library/behaviours/sort-by/applications/interfaces/gateways/IRepository.ts

@@ -0,0 +1,8 @@
+import ISortBy from '../../../domain/entities/interfaces/ISortBy';
+
+interface IRepository {
+  init(state: any): void;
+  getSortByEntity(): ISortBy;
+}
+
+export default IRepository;

package/es/library/behaviours/sort-by/applications/interfaces/gateways/IService.ts

@@ -0,0 +1,7 @@
+import SortBy from '../../usecases/SortBy';
+
+interface IService {
+  sortByUseCase: SortBy;
+}
+
+export default IService;

package/es/library/behaviours/sort-by/applications/interfaces/input/SortByInputModel.ts

@@ -0,0 +1,6 @@
+type SortByInputModel = {
+  id: string;
+  name: string;
+  dispatch: Function;
+};
+export default SortByInputModel;

package/es/library/behaviours/sort-by/applications/interfaces/output/IPresenter.ts

@@ -0,0 +1,6 @@
+import SortByOutputModel from './SortByOutputModel';
+
+export interface IPresenter {
+  updateDependencies(state: any, updateState: Function): void;
+  updateSortBy(sortByData: SortByOutputModel): void;
+}

package/es/library/behaviours/sort-by/applications/interfaces/output/SortByOutputModel.ts

@@ -0,0 +1,9 @@
+import SortOrder from '@bc/sort-by/SortOrderEnum';
+
+type SortByOutputModel = {
+  id: string;
+  name: string;
+  order: SortOrder;
+};
+
+export default SortByOutputModel;

package/es/library/behaviours/sort-by/applications/usecases/AbstractUseCase.ts

@@ -0,0 +1,17 @@
+import IUseCase from '@cc/architecture/IUseCase';
+import UseCaseDependencies from '../interfaces/UseCaseDependencies';
+
+abstract class AbstractUseCase<InputModel> implements IUseCase<InputModel> {
+  constructor(protected dependencies: UseCaseDependencies) {}
+
+  abstract execute(inputModel: InputModel): void;
+
+  updateDependencies(state, updateState): void {
+    const { repository, presenter } = this.dependencies;
+
+    repository.init(state);
+    presenter.updateDependencies(state, updateState);
+  }
+}
+
+export default AbstractUseCase;

package/es/library/behaviours/sort-by/applications/usecases/SortBy.ts

@@ -0,0 +1,22 @@
+import { SORTBY_SORTED } from '@bc/sort-by/Constants';
+import SortByInputModel from '../interfaces/input/SortByInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class SortBy extends AbstractUseCase<SortByInputModel> {
+  public execute(input: SortByInputModel): void {
+    const { id, name, dispatch } = input;
+    const { repository, presenter } = this.dependencies;
+
+    const sortBy = repository.getSortByEntity();
+    sortBy.doSorting(id, name);
+
+    presenter.updateSortBy(sortBy.toObject());
+
+    dispatch({
+      type: SORTBY_SORTED,
+      payload: { sortBy: sortBy.toObject() }
+    });
+  }
+}
+
+export default SortBy;

package/es/library/behaviours/sort-by/domain/entities/SortBy.ts

@@ -0,0 +1,38 @@
+import SortOrderEnum from '@bc/sort-by/SortOrderEnum';
+import ISortBy from './interfaces/ISortBy';
+
+class SortBy implements ISortBy {
+  constructor(
+    private id: string,
+    private name: string,
+    private order: SortOrderEnum
+  ) {}
+
+  private toggleSort() {
+    if (this.order === SortOrderEnum.ASC) {
+      this.order = SortOrderEnum.DES;
+    } else {
+      this.order = SortOrderEnum.ASC;
+    }
+  }
+
+  private resetSortBy(id: string, name: string) {
+    this.id = id;
+    this.name = name;
+    this.order = SortOrderEnum.ASC;
+  }
+
+  toObject() {
+    return { id: this.id, name: this.name, order: this.order };
+  }
+
+  doSorting(id: string, name: string) {
+    if (this.id === id) {
+      this.toggleSort();
+    } else {
+      this.resetSortBy(id, name);
+    }
+  }
+}
+
+export default SortBy;

package/es/library/behaviours/sort-by/domain/entities/interfaces/ISortBy.ts

@@ -0,0 +1,8 @@
+import SortOrder from '@bc/sort-by/SortOrderEnum';
+
+interface ISortBy {
+  toObject(): { id: string; name: string; order: SortOrder };
+  doSorting(id: string, name: string): void;
+}
+
+export default ISortBy;

package/es/library/behaviours/sort-by/frameworks/ui/ActionsHandlerFactory.ts

@@ -0,0 +1,21 @@
+import SortByActionHandlers from '../../../../../bc/sort-by/ActionHandlers';
+import { SORTBY_SORT } from '../../../../../bc/sort-by/Constants';
+import SortByController from '../../adapters/controllers/SortBy';
+import Repository from '../../adapters/gateway/Repository';
+import Service from '../../adapters/gateway/Service';
+import Presenter from '../../adapters/presenter/Presenter';
+
+// TODO: Rename as EventHandlersFactory
+class ActionsHandlersFactory {
+  static create(): SortByActionHandlers {
+    const presenter = new Presenter();
+    const repository = new Repository();
+    const service = new Service({ presenter, repository });
+    const controller = new SortByController(service);
+
+    return {
+      [SORTBY_SORT]: controller.handle
+    };
+  }
+}
+export default ActionsHandlersFactory;

package/es/library/behaviours/sort-by/frameworks/ui/DemoBehaviour.ts

@@ -0,0 +1,18 @@
+import Properties from '../../../../../bc/sort-by/Properties';
+import Behaviour from '../../../../../cc/component/Behaviour';
+
+
+// REVIEW: Class never used
+class DemoBehaviour {
+  static create(): Behaviour {
+    return {
+      name: 'demo_behaviour',
+      setInitialState: () => ({}),
+      properties: Properties,
+      eventHandlers: {
+        "DEMO":()=>{alert('demo')}
+      }
+    };
+  }
+}
+export default DemoBehaviour;

package/es/library/behaviours/sort-by/frameworks/ui/SortByBehaviourFactory.ts

@@ -0,0 +1,19 @@
+import Properties from '@bc/sort-by/Properties';
+import Behaviour from '@cc/component/Behaviour';
+import ActionsHandlerFactory from './ActionsHandlerFactory';
+
+class SortByBehaviourFactory {
+  static create(): Behaviour {
+    return {
+      name: 'sortBy',
+      setInitialState: ({ properties }) => {
+        const { sortBy } = properties;
+        return sortBy || {};
+      },
+      properties: Properties,
+      eventHandlers: ActionsHandlerFactory.create()
+    };
+  }
+}
+
+export default SortByBehaviourFactory;

package/es/library/behaviours/text-to-field-click/adapters/controllers/ClickController.ts

@@ -0,0 +1,17 @@
+import { EventHandlerParams } from '@cc/component/EventHandlers';
+import ClickUseCase from '../../applications/usecases/ClickUseCase';
+
+class ClickController {
+  constructor(private clickUseCase: ClickUseCase) {
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(event: EventHandlerParams): void {
+    const { state, dispatch } = event;
+    const { clickUseCase } = this;
+    clickUseCase.updateDependencies(state);
+    clickUseCase.execute({ dispatch });
+  }
+}
+
+export default ClickController;

package/es/library/behaviours/text-to-field-click/adapters/gateway/Repository.ts

@@ -0,0 +1,16 @@
+import IFieldEventConverter from '../../domain/entities/interfaces/IFieldEventConverter';
+import FieldEventConverter from '../../domain/entities/FieldEventConverter';
+import IRepository from '../../applications/interfaces/gateways/IRepository';
+
+export default class Repository implements IRepository {
+  private state: any;
+
+  init(state: any) {
+    this.state = state;
+  }
+
+  getFieldEventConverter(): IFieldEventConverter {
+    const { name } = this.state.properties;
+    return new FieldEventConverter(name);
+  }
+}

package/es/library/behaviours/text-to-field-click/applications/interfaces/UseCaseDependencies.ts

@@ -0,0 +1,7 @@
+import IRepository from './gateways/IRepository';
+
+type UseCaseDependencies = {
+  repository: IRepository;
+};
+
+export default UseCaseDependencies;

package/es/library/behaviours/text-to-field-click/applications/interfaces/gateways/IRepository.ts

@@ -0,0 +1,8 @@
+import IFieldEventConverter from '../../../domain/entities/interfaces/IFieldEventConverter';
+
+interface IRepository {
+  init(state: any): void;
+  getFieldEventConverter(): IFieldEventConverter;
+}
+
+export default IRepository;

package/es/library/behaviours/text-to-field-click/applications/interfaces/input/ClickUseCaseInputModel.ts

@@ -0,0 +1,4 @@
+type ClickUseCaseInputModel = {
+  dispatch: Function;
+};
+export default ClickUseCaseInputModel;

package/es/library/behaviours/text-to-field-click/applications/usecases/AbstractUseCase.ts

@@ -0,0 +1,15 @@
+import IUseCase from '@cc/architecture/IUseCase';
+import UseCaseDependencies from '../interfaces/UseCaseDependencies';
+
+abstract class AbstractUseCase<InputModel> implements IUseCase<InputModel> {
+  constructor(protected dependencies: UseCaseDependencies) {}
+
+  abstract execute(inputModel: InputModel): void;
+
+  updateDependencies(state): void {
+    const { repository } = this.dependencies;
+    repository.init(state);
+  }
+}
+
+export default AbstractUseCase;

package/es/library/behaviours/text-to-field-click/applications/usecases/ClickUseCase.ts

@@ -0,0 +1,14 @@
+import ClickUseCaseInputModel from '../interfaces/input/ClickUseCaseInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class ClickUseCase extends AbstractUseCase<ClickUseCaseInputModel> {
+  public execute(input: ClickUseCaseInputModel): void {
+    const { repository } = this.dependencies;
+    const { dispatch } = input;
+    const fieldEventConverter = repository.getFieldEventConverter();
+
+    dispatch(fieldEventConverter.getFieldClickEvent());
+  }
+}
+
+export default ClickUseCase;

package/es/library/behaviours/text-to-field-click/domain/entities/FieldEventConverter.ts

@@ -0,0 +1,16 @@
+import FieldConstants from '@cc/fields/field/Constants';
+import IFieldEventConverter from './interfaces/IFieldEventConverter';
+
+class FieldEventConverter implements IFieldEventConverter {
+  constructor(private fieldName: string) {}
+  getFieldClickEvent() {
+    return {
+      type: FieldConstants.FIELD_CLICKED,
+      payload: {
+        fieldName: this.fieldName
+      }
+    };
+  }
+}
+
+export default FieldEventConverter;

package/es/library/behaviours/text-to-field-click/domain/entities/interfaces/IFieldEventConverter.ts

@@ -0,0 +1,12 @@
+type EventModel = {
+  type: string;
+  payload: {
+    fieldName: string;
+  };
+};
+
+interface IFieldEventConverter {
+  getFieldClickEvent(): EventModel;
+}
+
+export default IFieldEventConverter;

package/es/library/behaviours/text-to-field-click/frameworks/ui/EventHandlersFactory.ts

@@ -0,0 +1,17 @@
+import EventHandlers from '@cc/component/EventHandlers';
+import TextConstants from '@cc/text/Constants';
+import Repository from '../../adapters/gateway/Repository';
+import ClickController from '../../adapters/controllers/ClickController';
+import ClickUseCase from '../../applications/usecases/ClickUseCase';
+
+export class EventHandlersFactory {
+  static create(): EventHandlers {
+    const repository = new Repository();
+    const clickUseCase = new ClickUseCase({ repository });
+    const clickController = new ClickController(clickUseCase);
+
+    return {
+      [TextConstants.TEXT_CLICKED]: clickController.handle
+    };
+  }
+}

package/es/library/behaviours/text-to-field-click/frameworks/ui/TextToFieldClickBehaviourFactory.ts

@@ -0,0 +1,15 @@
+import Behaviour from '@cc/component/Behaviour';
+import { EventHandlersFactory } from './EventHandlersFactory';
+
+class TextToFieldClickBehaviourFactory {
+  static create(): Behaviour {
+    return {
+      name: 'textToFieldClick',
+      setInitialState: () => undefined,
+      properties: {},
+      eventHandlers: EventHandlersFactory.create()
+    };
+  }
+}
+
+export default TextToFieldClickBehaviourFactory;

package/es/library/custom-component/adapters/controllers/Controller.ts

@@ -0,0 +1,30 @@
+import IService from '../../applications/interfaces/gateways/IService';
+
+class Controller {
+  constructor(private service: IService) {}
+  initialize(input) {
+    const { initializeUseCase } = this.service;
+    initializeUseCase.execute(input);
+  }
+  mount() {
+    const { mountUseCase } = this.service;
+    mountUseCase.execute();
+  }
+  unmount() {
+    const { unmountUseCase } = this.service;
+    unmountUseCase.execute();
+  }
+  updateProperties(newProps) {
+    const { updatePropertiesUseCase } = this.service;
+    updatePropertiesUseCase.execute(newProps);
+  }
+  updateState(newState) {
+    const { updateStateUseCase } = this.service;
+    updateStateUseCase.execute(newState);
+  }
+  dispatch(action) {
+    const { dispatchUseCase } = this.service;
+    dispatchUseCase.execute(action);
+  }
+}
+export default Controller;

package/es/library/custom-component/adapters/controllers/interface/IController.ts

@@ -0,0 +1,20 @@
+import Component from "../../../../../cc/component/component";
+
+export type IInitController = (
+  input: Component,
+  newProps: any,
+  helpers
+) => void;
+export type IMountController = () => void;
+export type IUnmountController = () => void;
+export type IUpdateProperties = (props: any) => void;
+export type IUpdateState = (state: any) => void;
+
+interface IController {
+  init: IInitController;
+  mount: IMountController;
+  unmount: IUnmountController;
+  updateState: IUpdateProperties;
+  updateProperties: IUpdateState;
+}
+export default IController;

package/es/library/custom-component/adapters/gateways/event-manager/EventManager.ts

@@ -0,0 +1,75 @@
+import IEventManager from '../../../applications/interfaces/gateways/IEventManager';
+
+// @ts-ignore
+if (__DEVELOPMENT__) {
+  globalThis.enableEventLogging = false;
+}
+
+class EventManager implements IEventManager {
+  private _element;
+  constructor() {}
+  setElement(element) {
+    this._element = element;
+  }
+  getElement() {
+    return this._element;
+  }
+  subscribe(events: Map<string, Array<Function>>) {
+    events.forEach((eventHandlers, key) => {
+      this._element &&
+        eventHandlers.map(eventHandler => {
+          this._element.addEventListener(key, eventHandler);
+        });
+    });
+  }
+  unSubscribe(events: Map<string, Array<Function>>) {
+    events.forEach((eventHandlers, key) => {
+      this._element &&
+        eventHandlers.map(eventHandler => {
+          this._element.removeEventListener(key, eventHandler);
+        });
+    });
+  }
+  dispatch(event: { type: string; payload: any; metaData: any }) {
+    let { payload, metaData, type } = event;
+
+    this.log(type, payload, metaData);
+    if (!this._element) {
+      console.error('Error: Element `ref` not found!', this._element, type, {
+        payload,
+        metaData
+      });
+    }
+    this.dispatchEvent({ type, payload, metaData });
+  }
+
+  private dispatchEvent(event: { type: string; payload: any; metaData: any }) {
+    let { payload, metaData, type } = event;
+    this._element &&
+      this._element.dispatchEvent(
+        new CustomEvent(type, {
+          bubbles: true,
+          detail: { payload, metaData }
+        })
+      );
+  }
+
+  private log(type, payload, metaData) {
+    // @ts-ignore
+    if (__DEVELOPMENT__) {
+      if (globalThis.enableEventLogging && type) {
+        const index = type.indexOf('#');
+        console.log(
+          '%cEvent %c' + type.slice(0, index) + '%c' + type.slice(index),
+          'font-weight: bold',
+          'color: #FF6F61;font-weight: bold',
+          'color: #FFA500;font-weight: bold',
+          {payload,
+          metaData}
+        );
+      }
+    }
+  }
+}
+
+export default EventManager;

package/es/library/custom-component/adapters/gateways/repository/Repository.ts

@@ -0,0 +1,17 @@
+import IComponent from '../../../domain/entities/interfaces/IComponent';
+import IRepository from '../../../applications/interfaces/gateways/IRepository';
+
+class Repository implements IRepository {
+  component: IComponent;
+  constructor() {}
+  getComponent() {
+    return this.component;
+  }
+  save(value) {
+    this.component = value;
+  }
+  clear() {
+    this.component = null;
+  }
+}
+export default Repository;

package/es/library/custom-component/adapters/gateways/service/Service.ts

@@ -0,0 +1,29 @@
+import { ActionHandlerParams } from '../../../../../cc/component/ActionHandlers';
+import UseCase from '../../../applications/interfaces/UseCase';
+import DispatchUseCase from '../../../applications/usecases/DispatchUseCase';
+import InitializeUseCase from '../../../applications/usecases/InitializeUseCase';
+import MountUsecase from '../../../applications/usecases/MountUseCase';
+import UnmountUsecase from '../../../applications/usecases/UnmountUseCase';
+
+import UpdatePropertyUseCase from '../../../applications/usecases/UpdatePropertyUseCase';
+import UpdateStateUseCase from '../../../applications/usecases/UpdateStateUseCase';
+import IService from '../../../applications/interfaces/gateways/IService';
+
+class Service implements IService {
+  initializeUseCase: InitializeUseCase;
+  mountUseCase: MountUsecase;
+  unmountUseCase: UnmountUsecase;
+  updatePropertiesUseCase: UpdatePropertyUseCase;
+  updateStateUseCase: UpdateStateUseCase;
+  constructor(dependencies) {
+    this.initializeUseCase = new InitializeUseCase(dependencies);
+    this.mountUseCase = new MountUsecase(dependencies);
+    this.unmountUseCase = new UnmountUsecase(dependencies);
+    this.updatePropertiesUseCase = new UpdatePropertyUseCase(dependencies);
+    this.updateStateUseCase = new UpdateStateUseCase(dependencies);
+    this.dispatchUseCase = new DispatchUseCase(dependencies);
+  }
+  dispatchUseCase: UseCase<ActionHandlerParams>;
+}
+
+export default Service;

package/es/library/custom-component/adapters/presenters/Presenter.ts

@@ -0,0 +1,15 @@
+import OutputBoundary from '../../applications/interfaces/output/OutputBoundary';
+
+class Presenter implements OutputBoundary {
+  private updateState;
+  constructor({ updateState }) {
+    this.updateState = updateState;
+  }
+  setError(error) {
+    this.updateState({ error: error });
+  }
+  render(state) {
+    this.updateState(state);
+  }
+}
+export default Presenter;