@zohodesk/library-platform 1.0.0-exp.1

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

@@ -0,0 +1,24 @@
+import State from '../../usecases/interfaces/output/BehaviourStateModel';
+import IPresenter from '../../usecases/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/src/library/behaviours/list-selection/entities/ListItemSelection.ts

@@ -0,0 +1,95 @@
+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)); // 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;
+        }
+        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];
+
+    let itemsForSelection = this.itemIds.slice(start, end + 1);
+    itemsForSelection = itemsForSelection.filter(i => !this.isSelected(i));
+    const yetToSelectCount = this.maxSelectionCount - this.selected.length;
+    if (itemsForSelection.length > yetToSelectCount) {
+      if (isForward) {
+        itemsForSelection.splice(yetToSelectCount + 1);
+      } else {
+        itemsForSelection.splice(0, itemsForSelection.length - yetToSelectCount);
+      }
+    }
+
+    itemsForSelection.forEach(this.getStrategy(this.itemIds.at(endIndex)));
+  }
+
+  toggleUpto(id: string): void {
+    let lastItem = this.selected.at(-1);
+    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/src/library/behaviours/list-selection/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/src/library/behaviours/list-selection/entities/interfaces/ListSelectionModel.ts

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

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

@@ -0,0 +1,39 @@
+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 repository = new Repository();
+    const presenter = new Presenter();
+    const service = new Service({ repository, presenter });
+
+    const controller = {
+      init: new InitializeController(service).handle,
+      updateProperties: new UpdateController(service).handle,
+      destruct: new DestructController(service).handle,
+      toggleItems: new SelectionController(service).handle,
+      toggleAll: new AllSelectionController(service).handle,
+      toggleRange: new RangeSelectionController(service).handle
+    };
+
+    return {
+      ['MOUNT']: controller.init,
+      ['UPDATE_PROPERTIES']: controller.updateProperties,
+      ['UNMOUNT']: controller.destruct,
+      [LIST_SELECTION_TOGGLE_ITEMS]: controller.toggleItems,
+      [LIST_SELECTION_TOGGLE_ALL]: controller.toggleAll,
+      [LIST_SELECTION_TOGGLE_ITEMS_IN_RANGE]: controller.toggleRange
+    };
+  }
+}
+
+export default ActionHandlerFactory;

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

@@ -0,0 +1,25 @@
+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: ({ properties }) => {
+        // We are not giving this feature!
+        // const { selectedItems } = properties.selectionConfig.selectedItems;
+        return {
+          selected: [],
+          hasAllSelected: false
+        };
+      },
+      eventHandlers: ActionHandlerFactory.create(),
+      events,
+      properties
+    };
+  }
+}
+
+export default ListItemSelectionBehaviourFactory;

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

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

package/src/library/behaviours/list-selection/usecases/interactors/Destruct.ts

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

package/src/library/behaviours/list-selection/usecases/interactors/Initialize.ts

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

package/src/library/behaviours/list-selection/usecases/interactors/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/src/library/behaviours/list-selection/usecases/interactors/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/src/library/behaviours/list-selection/usecases/interfaces/UseCase.ts

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

package/src/library/behaviours/list-selection/usecases/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/src/library/behaviours/list-selection/usecases/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/src/library/behaviours/list-selection/usecases/interfaces/gateways/IService.ts

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

package/src/library/behaviours/list-selection/usecases/interfaces/input/AllSelectionInputModel.ts

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

package/src/library/behaviours/list-selection/usecases/interfaces/input/DestructInputModel.ts

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

package/src/library/behaviours/list-selection/usecases/interfaces/input/InitializeInputModel.ts

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

package/src/library/behaviours/list-selection/usecases/interfaces/input/RangeSelectionInputModel.ts

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

package/src/library/behaviours/list-selection/usecases/interfaces/input/SelectionInputModel.ts

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

package/src/library/behaviours/list-selection/usecases/interfaces/output/BehaviourStateModel.ts

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

package/src/library/behaviours/list-selection/usecases/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/src/library/behaviours/local-storage/entities/Storage.ts

@@ -0,0 +1,16 @@
+import IStorage from "./interfaces/IStorage";
+
+class Storage implements IStorage {
+  private data: Map<string, any>;
+  setData(id: string, data: any): void {
+    this.data[id] = data;
+  }
+  getData(id: string) {
+    return this.data[id];
+  }
+  deleteData(id: string): void {
+    delete this.data[id];
+  }
+}
+
+export default Storage;

package/src/library/behaviours/local-storage/entities/interfaces/ILocalStorage.ts

@@ -0,0 +1,6 @@
+interface ILocalStorage {
+  setItem(id: string, data: string): void;
+  removeItem(id: string): any;
+  getItem(id: string): string;
+}
+export default ILocalStorage;

package/src/library/behaviours/local-storage/entities/interfaces/IStorage.ts

@@ -0,0 +1,6 @@
+interface IStorage {
+  setData(id: string, data: any): void;
+  getData(id: string): any;
+  deleteData(id: string): void;
+}
+export default IStorage;

package/src/library/behaviours/local-storage/usecases/interactors/AbstractUseCase.ts

@@ -0,0 +1,8 @@
+import InputDependencies from "../interfaces/InputDependencies";
+import UseCase from "../interfaces/UseCase";
+
+abstract class AbstractUseCase<InputModel> implements UseCase<InputModel> {
+  constructor(protected dependencies: InputDependencies) {}
+  abstract execute(inputModel: InputModel): void;
+}
+export default AbstractUseCase;

package/src/library/behaviours/local-storage/usecases/interactors/DeleteData.ts

@@ -0,0 +1,13 @@
+import IStorage from "../../entities/interfaces/IStorage";
+import DeleteDataInput from "../interfaces/input/DeleteDataInput";
+import AbstractUseCase from "./AbstractUseCase";
+
+class DeleteData extends AbstractUseCase<DeleteDataInput> {
+  execute(input: DeleteDataInput) {
+    let { repository } = this.dependencies;
+    let storage: IStorage = repository.getStorage();
+    storage.deleteData(input.id);
+    repository.setStorage(storage);
+  }
+}
+export default DeleteData;

package/src/library/behaviours/local-storage/usecases/interactors/GetData.ts

@@ -0,0 +1,13 @@
+import IStorage from "../../entities/interfaces/IStorage";
+import GetDataInput from "../interfaces/input/GetDataInput";
+import AbstractUseCase from "./AbstractUseCase";
+
+class GetData extends AbstractUseCase<GetDataInput> {
+  execute(input: GetDataInput) {
+    let { repository, presenter } = this.dependencies;
+    let storage: IStorage = repository.getStorage();
+    let data = storage.getData(input.id);
+    presenter.setData(data);
+  }
+}
+export default GetData;

package/src/library/behaviours/local-storage/usecases/interactors/SetData.ts

@@ -0,0 +1,13 @@
+import IStorage from "../../entities/interfaces/IStorage";
+import SetDataInput from "../interfaces/input/SetDataInput";
+import AbstractUseCase from "./AbstractUseCase";
+
+class SetData extends AbstractUseCase<SetDataInput> {
+  execute(input: SetDataInput) {
+    let { repository } = this.dependencies;
+    let storage: IStorage = repository.getStorage();
+    storage.setData(input.id, input.data);
+    repository.setStorage(storage);
+  }
+}
+export default SetData;

package/src/library/behaviours/local-storage/usecases/interfaces/InputDependencies.ts

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

package/src/library/behaviours/local-storage/usecases/interfaces/UseCase.ts

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

package/src/library/behaviours/local-storage/usecases/interfaces/gateways/IRepository.ts

@@ -0,0 +1,7 @@
+import IStorage from "../../../entities/interfaces/IStorage";
+
+interface IRepository {
+  getStorage(): IStorage;
+  setStorage(storage: IStorage): void;
+}
+export default IRepository;

package/src/library/behaviours/local-storage/usecases/interfaces/input/DeleteDataInput.ts

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

package/src/library/behaviours/local-storage/usecases/interfaces/input/GetDataInput.ts

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

package/src/library/behaviours/local-storage/usecases/interfaces/input/SetDataInput.ts

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

package/src/library/behaviours/local-storage/usecases/interfaces/output/IPresenter.ts

@@ -0,0 +1,4 @@
+interface IPresenter {
+  setData(data: any): void;
+}
+export default IPresenter;

package/src/library/behaviours/mouse-resizable/adapters/controllers/handlers/MountHandler.ts

@@ -0,0 +1,7 @@
+class MountHandler {
+  handle() {
+    document.body.addEventListener("mousemove", handleResize);
+    document.body.addEventListener("mouseup", stopResize);
+    document.body.addEventListener("mouseleave", stopResize);
+  }
+}

package/src/library/behaviours/mouse-resizable/adapters/controllers/handlers/StartResize.ts

@@ -0,0 +1,11 @@
+class StartResize {
+  // const startResize = useLatestCallBack((mouseEvent) => {
+  //   addEventListenersForMoveAndEnd();
+  //   onDragStart &&
+  //     onDragStart({
+  //       mouseX: mouseEvent.clientX,
+  //       mouseY: mouseEvent.clientY,
+  //     });
+  //   setIsResizing(true);
+  // })
+}

package/src/library/behaviours/mouse-resizable/frameworks/MouseResizableFactory.ts

@@ -0,0 +1,28 @@
+import Behaviour from "../../../cc/component/Behaviour";
+import handlers from "../adapters/controllers/handlers/index";
+
+class MouseResizableFactory {
+  create(): Behaviour {
+    return {
+      name: "mouseResizable",
+      properties: {
+        isFetching: {
+          required: false,
+          typeMetadata: {
+            schema: {
+              type: "boolean",
+            },
+          },
+          defaultValue: false,
+        },
+      },
+      setInitialState: ({ properties }) => {
+        return {
+          isFetching: properties.isFetching || false,
+        };
+      },
+      actionHandlers: handlers(window.fetch, defaultHeaders),
+    };
+  }
+}
+export default MouseResizableFactory;

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

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

package/src/library/behaviours/sort-by/adapters/controllers/Initialize.ts

@@ -0,0 +1,11 @@
+import { SORTBY_SORT } from "@bc/sort-by/Constants";
+import AbstractController from "./AbstractController";
+
+class Initialize extends AbstractController {
+  handle(event) {
+    const { dispatch, action } = event;
+    const { id } = action.payload;
+
+    
+  }
+}

package/src/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/src/library/behaviours/sort-by/adapters/gateway/Repository.ts

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