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

package/es/desk-frameworks/table-connected/frameworks/TableConnectedFactory.ts

@@ -0,0 +1,49 @@
+import Properties from '@cc/table-connected/Properties';
+import { createCustomComponent } from '@library/custom-component';
+import ZFieldBehaviourFactory from '@platform/zfield/frameworks/ZFieldBehaviourFactory';
+import ZHttpBehaviourFactory from '@platform/zhttp/frameworks/ZHttpBehaviourFactory';
+import TableTranslator from '@platform/zlist/adapters/presenters/TableTranslator';
+import ZListBehaviourFactory from '@platform/zlist/frameworks/ZListBehaviourFactory';
+import RecordBehaviourFactory from '@platform/zrecord/frameworks/RecordBehaviourFactory';
+import EventHandlersFactory from './EventHandlersFactory';
+import TableConnectedView from './TableConnectedView';
+import defaultDataSource from '@platform/data-source';
+import DataSourceBehaviourFactory from '@platform/zdata-source/frameworks/DataBrokerBehaviourFactory';
+import ClientActionsBehaviourFactory from '@platform/client-actions/behaviour/zclient-actions/frameworks/ClientActionsBehaviourFactory';
+
+export default class TableConnectedFactory {
+  static create({ name, dataBroker, dataSource, eventHandlers = {}, View = TableConnectedView }) {
+    if (!dataSource) {
+      console.warn('Desk Platform Warning: dataBroker is deprecated, use dataSource instead');
+      dataSource = dataBroker;
+    }
+    const _dataSource = {
+      ...dataSource,
+      httpTemplates: {
+        ...defaultDataSource.httpTemplates,
+        ...dataSource?.httpTemplates
+      }
+    };
+
+    return createCustomComponent({
+      name: name,
+      View: View,
+      properties: Properties,
+      eventHandlers: EventHandlersFactory.create(eventHandlers),
+      transformState: TableTranslator.transformState,
+      behaviours: [
+        ZHttpBehaviourFactory.create(),
+        DataSourceBehaviourFactory.create(),
+        RecordBehaviourFactory.create(_dataSource.httpTemplates),
+        ClientActionsBehaviourFactory.create({
+          getClientActions: _dataSource.httpTemplates.getClientActions
+        }),
+        ZFieldBehaviourFactory.create({
+          availableFields: _dataSource.httpTemplates.getAvailableFields,
+          selectedFields: _dataSource.httpTemplates.getSelectedFields
+        }),
+        ZListBehaviourFactory.create()
+      ]
+    });
+  }
+}

package/es/desk-frameworks/table-connected/frameworks/TableConnectedView.tsx

@@ -0,0 +1,28 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import TableList from '@library/dot/components/table-list/frameworks/ui/TableList';
+
+function View({ state }, ref) {
+  const { isLoading, data = [], rowActionsConfig, rowCursor, properties, emptyStateUiType } = state;
+  const { preferences, selectionConfig } = properties;
+  const { autoColumnSizing } = preferences || {};
+
+  return (
+    <TableList
+      data={data}
+      rowCursor={rowCursor}
+      getRef={ref}
+      isFlexibleColumns={autoColumnSizing}
+      rowActionsConfig={rowActionsConfig}
+      isLoading={isLoading}
+      emptyStateUiType={emptyStateUiType}
+      selectionConfig={selectionConfig}
+    />
+  );
+}
+
+export default View;
+
+View.propTypes = {
+  state: PropTypes.object
+};

package/es/index.ts

@@ -0,0 +1,8 @@
+export * as CC from './cc';
+export * as BC from './bc';
+
+export { TableConnectedFactory } from './desk-frameworks';
+export { ComponentRegistry, createCustomComponent } from './library';
+
+export { default as TableFieldComponents } from './library/dot/legacy-to-new-arch/table-field-components';
+export * as Components from './library/dot/legacy-to-new-arch';

package/es/library/behaviours/list-selection/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/list-selection/adapters/controllers/AllSelectionController.ts

@@ -0,0 +1,13 @@
+import AbstractController from './AbstractController';
+
+class AllSelectionController extends AbstractController {
+  handle(event): void {
+    const { state, updateState } = event;
+    const { allSelectionUseCase } = this.service;
+
+    allSelectionUseCase.updateDependencies(state, updateState);
+    allSelectionUseCase.execute();
+  }
+}
+
+export default AllSelectionController;

package/es/library/behaviours/list-selection/adapters/controllers/DestructController.ts

@@ -0,0 +1,13 @@
+import AbstractController from './AbstractController';
+
+class DestructController extends AbstractController {
+  handle(event): void {
+    const { destructUseCase } = this.service;
+    const { state, updateState } = event;
+
+    destructUseCase.updateDependencies(state, updateState);
+    destructUseCase.execute();
+  }
+}
+
+export default DestructController;

package/es/library/behaviours/list-selection/adapters/controllers/InitializeController.ts

@@ -0,0 +1,13 @@
+import AbstractController from './AbstractController';
+
+class InitializeController extends AbstractController {
+  handle(event): void {
+    const { initializeUseCase } = this.service;
+    const { state, updateState } = event;
+
+    initializeUseCase.updateDependencies(state, updateState);
+    initializeUseCase.execute();
+  }
+}
+
+export default InitializeController;

package/es/library/behaviours/list-selection/adapters/controllers/RangeSelectionController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class RangeSelectionController extends AbstractController {
+  handle(event): void {
+    const { state, action, updateState } = event;
+    const { id } = action.payload;
+    const { rangeSelectionUseCase } = this.service;
+
+    rangeSelectionUseCase.updateDependencies(state, updateState);
+    rangeSelectionUseCase.execute({ id });
+  }
+}
+
+export default RangeSelectionController;

package/es/library/behaviours/list-selection/adapters/controllers/SelectionController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class SelectionController extends AbstractController {
+  handle(event): void {
+    const { state, action, updateState } = event;
+    const { selected } = action.payload;
+    const { selectionUseCase } = this.service;
+
+    selectionUseCase.updateDependencies(state, updateState);
+    selectionUseCase.execute({ selected });
+  }
+}
+
+export default SelectionController;

package/es/library/behaviours/list-selection/adapters/controllers/UpdateController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class UpdateController extends AbstractController {
+  handle(event): void {
+    const { initializeUseCase } = this.service;
+    const { state, updateState } = event;
+    const { selected } = state.behaviours.selection;
+
+    initializeUseCase.updateDependencies(state, updateState);
+    initializeUseCase.execute({ selected });
+  }
+}
+
+export default UpdateController;

package/es/library/behaviours/list-selection/adapters/gateways/Repository.ts

@@ -0,0 +1,26 @@
+import IListItemSelection from '../../domain/entities/interfaces/IListItemSelection';
+import ListItemSelection from '../../domain/entities/ListItemSelection';
+import IRepository from '../../applications/interfaces/gateways/IRepository';
+
+class Repository implements IRepository {
+  private state;
+
+  init(state): void {
+    this.state = state;
+  }
+
+  getListItemSelection(): IListItemSelection {
+    const { behaviours, properties } = this.state;
+    /* eslint-disable-next-line @zohodesk/architecturerules/no-defaultProps-rule */
+    const { selected } = behaviours?.selection || {};
+    /* eslint-disable-next-line @zohodesk/architecturerules/no-defaultProps-rule */
+    const { selectionConfig, data } = properties || {};
+
+    const itemIds: string[] = data?.rows.map(item => item.id);
+    const maxSelectionCount: number = selectionConfig?.maxSelectionCount;
+
+    return new ListItemSelection(selected, itemIds, maxSelectionCount);
+  }
+}
+
+export default Repository;

package/es/library/behaviours/list-selection/adapters/gateways/Service.ts

@@ -0,0 +1,25 @@
+import Initialize from '../../applications/usecases/Initialize';
+import AllItemsSelection from '../../applications/usecases/AllItemSelection';
+import ItemRangeSelection from '../../applications/usecases/RangeSelection';
+import ItemsSelection from '../../applications/usecases/ItemsSelection';
+import IService from '../../applications/interfaces/gateways/IService';
+import UseCaseDependencies from '../../applications/interfaces/UseCaseDependencies';
+import Destruct from '../../applications/usecases/Destruct';
+
+class Service implements IService {
+  initializeUseCase: Initialize;
+  destructUseCase: Destruct;
+  selectionUseCase: ItemsSelection;
+  allSelectionUseCase: AllItemsSelection;
+  rangeSelectionUseCase: ItemRangeSelection;
+
+  constructor(dependencies: UseCaseDependencies) {
+    this.initializeUseCase = new Initialize(dependencies);
+    this.destructUseCase = new Destruct(dependencies);
+    this.selectionUseCase = new ItemsSelection(dependencies);
+    this.allSelectionUseCase = new AllItemsSelection(dependencies);
+    this.rangeSelectionUseCase = new ItemRangeSelection(dependencies);
+  }
+}
+
+export default Service;

package/es/library/behaviours/list-selection/adapters/presenters/Presenter.ts

@@ -0,0 +1,24 @@
+import State from '../../applications/interfaces/output/BehaviourStateModel';
+import IPresenter from '../../applications/interfaces/output/IPresenter';
+
+class Presenter implements IPresenter {
+  private state: any;
+  private updateState: Function;
+
+  updateDependencies(state: any, updateState: Function): void {
+    this.state = state;
+    this.updateState = updateState;
+  }
+
+  updateListItemSelection(listItemSelection: State): void {
+    this.updateState({
+      ...this.state,
+      behaviours: {
+        ...this.state.behaviours,
+        selection: listItemSelection
+      }
+    });
+  }
+}
+
+export default Presenter;

package/es/library/behaviours/list-selection/applications/interfaces/UseCase.ts

@@ -0,0 +1,5 @@
+interface IUseCase<T> {
+  execute(input: T): void;
+}
+
+export default IUseCase;

package/es/library/behaviours/list-selection/applications/interfaces/UseCaseDependencies.ts

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

package/es/library/behaviours/list-selection/applications/interfaces/gateways/IRepository.ts

@@ -0,0 +1,8 @@
+import IListItemSelection from '../../../entities/interfaces/IListItemSelection';
+
+interface IRepository {
+  init(entity: IListItemSelection): void;
+  getListItemSelection(): IListItemSelection;
+}
+
+export default IRepository;

package/es/library/behaviours/list-selection/applications/interfaces/gateways/IService.ts

@@ -0,0 +1,15 @@
+import Initialize from '../../usecases/Initialize';
+import AllItemsSelection from '../../usecases/AllItemSelection';
+import ItemRangeSelection from '../../usecases/RangeSelection';
+import ItemsSelection from '../../usecases/ItemsSelection';
+import Destruct from '../../usecases/Destruct';
+
+interface IService {
+  initializeUseCase: Initialize;
+  destructUseCase: Destruct;
+  selectionUseCase: ItemsSelection;
+  allSelectionUseCase: AllItemsSelection;
+  rangeSelectionUseCase: ItemRangeSelection;
+}
+
+export default IService;

package/es/library/behaviours/list-selection/applications/interfaces/input/AllSelectionInputModel.ts

@@ -0,0 +1,3 @@
+type AllSelectionInputModel = null;
+
+export default AllSelectionInputModel;

package/es/library/behaviours/list-selection/applications/interfaces/input/DestructInputModel.ts

@@ -0,0 +1,3 @@
+type DestructInputModel = {};
+
+export default DestructInputModel;

package/es/library/behaviours/list-selection/applications/interfaces/input/InitializeInputModel.ts

@@ -0,0 +1,5 @@
+type InitailizeInputModel = {
+  selected: string[];
+};
+
+export default InitailizeInputModel;

package/es/library/behaviours/list-selection/applications/interfaces/input/RangeSelectionInputModel.ts

@@ -0,0 +1,5 @@
+type RangeSelectionInputModel = {
+  id: string;
+};
+
+export default RangeSelectionInputModel;

package/es/library/behaviours/list-selection/applications/interfaces/input/SelectionInputModel.ts

@@ -0,0 +1,5 @@
+type SelectionInputModel = {
+  selected: Array<string>;
+};
+
+export default SelectionInputModel;

package/es/library/behaviours/list-selection/applications/interfaces/output/BehaviourStateModel.ts

@@ -0,0 +1,6 @@
+type BehaviourState = {
+  selected: string[];
+  hasAllSelected: boolean;
+};
+
+export default BehaviourState;

package/es/library/behaviours/list-selection/applications/interfaces/output/IPresenter.ts

@@ -0,0 +1,8 @@
+import BehaviourState from "./BehaviourStateModel";
+
+interface IPresenter {
+  updateDependencies(state, updateState): void;
+  updateListItemSelection(listItemSelection: BehaviourState): void;
+}
+
+export default IPresenter;

package/es/library/behaviours/list-selection/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/list-selection/applications/usecases/AllItemSelection.ts

@@ -0,0 +1,14 @@
+import AbstractUseCase from './AbstractUseCase';
+import AllSelectionInputModel from '../interfaces/input/AllSelectionInputModel';
+
+class AllItemsSelection extends AbstractUseCase<AllSelectionInputModel> {
+  execute(): void {
+    const { repository, presenter } = this.dependencies;
+
+    const listItemSelection = repository.getListItemSelection();
+    listItemSelection.toggleAll();
+
+    presenter.updateListItemSelection(listItemSelection.toObject());
+  }
+}
+export default AllItemsSelection;

package/es/library/behaviours/list-selection/applications/usecases/Destruct.ts

@@ -0,0 +1,8 @@
+import DestructInputModel from '../interfaces/input/DestructInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class Destruct extends AbstractUseCase<DestructInputModel> {
+  execute(): void {}
+}
+
+export default Destruct;

package/es/library/behaviours/list-selection/applications/usecases/Initialize.ts

@@ -0,0 +1,13 @@
+import AbstractUseCase from './AbstractUseCase';
+import InitializeInputModel from '../interfaces/input/InitializeInputModel';
+
+class Initialize extends AbstractUseCase<InitializeInputModel> {
+  execute(): void {
+    const { repository, presenter } = this.dependencies;
+    const listItemSelection = repository.getListItemSelection();
+
+    presenter.updateListItemSelection(listItemSelection.toObject());
+  }
+}
+
+export default Initialize;

package/es/library/behaviours/list-selection/applications/usecases/ItemsSelection.ts

@@ -0,0 +1,16 @@
+import AbstractUseCase from './AbstractUseCase';
+import SelectionInputModel from '../interfaces/input/SelectionInputModel';
+
+class ItemsSelection extends AbstractUseCase<SelectionInputModel> {
+  execute(inputModel: SelectionInputModel): void {
+    const { repository, presenter } = this.dependencies;
+    const { selected } = inputModel;
+
+    const listItemSelection = repository.getListItemSelection();
+    listItemSelection.toggleItems(selected);
+
+    presenter.updateListItemSelection(listItemSelection.toObject());
+  }
+}
+
+export default ItemsSelection;

package/es/library/behaviours/list-selection/applications/usecases/RangeSelection.ts

@@ -0,0 +1,15 @@
+import AbstractUseCase from './AbstractUseCase';
+import RangeSelectionInputModel from '../interfaces/input/RangeSelectionInputModel';
+
+class ItemRangeSelection extends AbstractUseCase<RangeSelectionInputModel> {
+  execute(inputModel: RangeSelectionInputModel): void {
+    const { repository, presenter } = this.dependencies;
+    const { id } = inputModel;
+
+    let listItemSelection = repository.getListItemSelection();
+    listItemSelection.toggleUpto(id);
+
+    presenter.updateListItemSelection(listItemSelection.toObject());
+  }
+}
+export default ItemRangeSelection;

package/es/library/behaviours/list-selection/domain/entities/ListItemSelection.ts

@@ -0,0 +1,114 @@
+import IListItemSelection from './interfaces/IListItemSelection';
+import ListSelectionModel from './interfaces/ListSelectionModel';
+
+class ListItemSelection implements IListItemSelection {
+  constructor(
+    private selected: string[],
+    private itemIds: string[],
+    private maxSelectionCount: number
+  ) {
+    this.selected = this.selected.filter(selectedId => this.itemIds.includes(selectedId)); // NOTE: Remove items that does not exist
+  }
+
+  private selectItem(id: string): void {
+    this.selected.push(id);
+  }
+
+  private deselectItem(id: string): void {
+    this.selected = this.selected.filter(selectedId => selectedId !== id);
+  }
+
+  private isSelected(id: string): boolean {
+    return this.selected.includes(id);
+  }
+
+  private hasAllSelected(): boolean {
+    const hasMaxSelected = this.selected.length >= this.maxSelectionCount;
+    const allItemsSelected = this.selected.length === this.itemIds.length && this.selected.length > 0;
+
+    return hasMaxSelected || allItemsSelected;
+  }
+
+  private getStrategy(id: string) {
+    return (this.isSelected(id) ? this.deselectItem : this.selectItem).bind(this);
+  }
+
+  toggleItems(ids: string[]): void {
+    for (let id of ids) {
+      if (this.isSelected(id)) {
+        this.deselectItem(id);
+      } else {
+        if (this.hasAllSelected()) {
+          break;
+        }
+        this.selectItem(id);
+      }
+    }
+  }
+
+  toggleAll(): void {
+    if (!this.hasAllSelected()) {
+      for (let id of this.itemIds) {
+        if (this.hasAllSelected()) {
+          break;
+        }
+        if (!this.isSelected(id)) {
+          this.selectItem(id);
+        }
+      }
+    } else {
+      this.selected = [];
+    }
+  }
+
+  private toggleRange(startIndex: number, endIndex: number): void {
+    const isForward = startIndex < endIndex;
+    const [start, end] = isForward ? [startIndex, endIndex] : [endIndex, startIndex];
+    const itemsForSelection = this.itemIds.slice(start, end + 1);
+    const allSelected = itemsForSelection.every(id => this.isSelected(id));
+    const yetToSelectCount = this.maxSelectionCount - this.selected.length;
+    const itemsToSelect = itemsForSelection.filter(id => !this.isSelected(id));
+    this.rangeSelection(isForward, itemsForSelection, allSelected, yetToSelectCount, itemsToSelect);
+  }
+
+  private rangeSelection(isForward: boolean, itemsForSelection: string[], allSelected: boolean, yetToSelectCount: number, itemsToSelect: string[]): void {
+    if (allSelected) {
+      if (isForward) {
+        itemsForSelection.forEach(id => this.deselectItem(id))
+      } else {
+        itemsForSelection.reverse().forEach(id => this.deselectItem(id));
+      }
+    } else {
+      if (itemsToSelect.length > yetToSelectCount) {
+        if (isForward) {
+          itemsToSelect.splice(yetToSelectCount);
+        } else {
+          itemsToSelect.reverse();
+          itemsToSelect.splice(yetToSelectCount);
+          itemsToSelect.reverse();
+        }
+      }
+      if (isForward) {
+        itemsToSelect.forEach(id => this.selectItem(id))
+      } else {
+        itemsToSelect.reverse().forEach(id => this.selectItem(id));
+      }
+    }
+  }
+
+  toggleUpto(id: string): void {
+    let lastItem = this.selected.at(-1) || id;
+    let startIndex = this.itemIds.indexOf(lastItem);
+    let endIndex = this.itemIds.indexOf(id);
+    this.toggleRange(startIndex, endIndex);
+  }
+
+  toObject(): ListSelectionModel {
+    return {
+      selected: this.selected,
+      hasAllSelected: this.hasAllSelected()
+    };
+  }
+}
+
+export default ListItemSelection;

package/es/library/behaviours/list-selection/domain/entities/interfaces/IListItemSelection.ts

@@ -0,0 +1,10 @@
+import ListSelectionModel from './ListSelectionModel';
+
+interface IListItemSelection {
+  toggleItems(ids: string[]): void;
+  toggleAll(): void;
+  toggleUpto(id: string): void;
+  toObject(): ListSelectionModel;
+}
+
+export default IListItemSelection;

package/es/library/behaviours/list-selection/domain/entities/interfaces/ListSelectionModel.ts

@@ -0,0 +1,6 @@
+type ListSelectionModel = {
+  selected: string[];
+  hasAllSelected: boolean;
+};
+
+export default ListSelectionModel;

package/es/library/behaviours/list-selection/frameworks/ActionHandlerFactory.ts

@@ -0,0 +1,38 @@
+import ListSelectionActionHandlers from '@bc/list-selection/ActionHandlers';
+import { LIST_SELECTION_TOGGLE_ALL, LIST_SELECTION_TOGGLE_ITEMS, LIST_SELECTION_TOGGLE_ITEMS_IN_RANGE } from '@bc/list-selection/Constants';
+import InitializeController from '../adapters/controllers/InitializeController';
+import Repository from '../adapters/gateways/Repository';
+import Presenter from '../adapters/presenters/Presenter';
+import Service from '../adapters/gateways/Service';
+import SelectionController from '../adapters/controllers/SelectionController';
+import AllSelectionController from '../adapters/controllers/AllSelectionController';
+import RangeSelectionController from '../adapters/controllers/RangeSelectionController';
+import UpdateController from '../adapters/controllers/UpdateController';
+import DestructController from '../adapters/controllers/DestructController';
+
+class ActionHandlerFactory {
+  static create(): ListSelectionActionHandlers {
+    const service = this.createService();
+    
+    return this.createHandlers(service);
+  }
+
+  private static createService(): Service {
+    const repository = new Repository();
+    const presenter = new Presenter();
+    return new Service({ repository, presenter });
+  }
+
+  private static createHandlers(service: Service): ListSelectionActionHandlers {
+    return {
+      ['MOUNT']: new InitializeController(service).handle,
+      ['UPDATE_PROPERTIES']: new UpdateController(service).handle,
+      ['UNMOUNT']: new DestructController(service).handle,
+      [LIST_SELECTION_TOGGLE_ITEMS]: new SelectionController(service).handle,
+      [LIST_SELECTION_TOGGLE_ALL]: new AllSelectionController(service).handle,
+      [LIST_SELECTION_TOGGLE_ITEMS_IN_RANGE]: new RangeSelectionController(service).handle
+    };
+  }
+}
+
+export default ActionHandlerFactory;

package/es/library/behaviours/list-selection/frameworks/ListItemSelectionBehaviourFactory.ts

@@ -0,0 +1,23 @@
+import properties from '@bc/list-selection/Properties';
+import events from '@bc/list-selection/Actions';
+import ActionHandlerFactory from './ActionHandlerFactory';
+import Behaviour from '@cc/component/Behaviour';
+
+class ListItemSelectionBehaviourFactory {
+  static create(): Behaviour {
+    return {
+      name: 'selection',
+      setInitialState: () => {
+        return {
+          selected: [],
+          hasAllSelected: false
+        };
+      },
+      eventHandlers: ActionHandlerFactory.create(),
+      events,
+      properties
+    };
+  }
+}
+
+export default ListItemSelectionBehaviourFactory;