@zohodesk/library-platform 1.0.0-exp.1

package/src/library/custom-component/entities/EventHandlers.ts

@@ -0,0 +1,9 @@
+import IEventHandlers from "./interfaces/IEventHandlers";
+
+class EventHandlers implements IEventHandlers {
+  constructor(private handlers: Map<string, Function>) { }
+  public getEventHandlers() {
+    return this.handlers;
+  }
+}
+export default EventHandlers;

package/src/library/custom-component/entities/Events.ts

@@ -0,0 +1,18 @@
+import IPayload from "./interfaces/IPayload";
+import IAction from "./interfaces/IAction";
+
+class Action implements IAction {
+  private type: string;
+  private payload: IPayload;
+  constructor(type: string, payload: IPayload) {
+    this.type = type;
+    this.payload = payload;
+  }
+  public getType(): string {
+    return this.type;
+  }
+  public getPayload() {
+    return this.payload;
+  }
+}
+export default Action;

package/src/library/custom-component/entities/LifeCycleAction.ts

@@ -0,0 +1,31 @@
+import ILifeCycleAction from "./interfaces/ILifeCycleAction";
+
+export default class LifeCycleAction implements ILifeCycleAction {
+  mount: any;
+  unmount: any;
+  private contructUpdatePropertiesAction: Function;
+  constructor(name) {
+    this.mount = {
+      type: `${name}#MOUNT`
+    };
+    this.unmount = {
+      type: `${name}#UN_MOUNT`
+    };
+    this.contructUpdatePropertiesAction = (payload) => {
+      return {
+        type: `${name}#UPDATE_PROPERTIES`,
+        payload
+      };
+    };
+  }
+
+  getMountAction() {
+    return this.mount;
+  }
+  getUnmountAction() {
+    return this.unmount;
+  }
+  getUpdatePropertiesAction(payload: any) {
+    return this.contructUpdatePropertiesAction(payload);
+  }
+}

package/src/library/custom-component/entities/Payload.ts

@@ -0,0 +1,17 @@
+import IPayload from "./interfaces/IPayload";
+import ISchema from "./interfaces/ISchema";
+
+export default class Payload implements IPayload {
+  name: string;
+  typeMetadata: { schema: ISchema };
+  constructor(name: string, typeMetadata) {
+    this.name = name;
+    this.typeMetadata = typeMetadata;
+  }
+  public getName(): string {
+    return this.name;
+  }
+  public getTypeMetadata() {
+    return this.typeMetadata;
+  }
+}

package/src/library/custom-component/entities/Properties.ts

@@ -0,0 +1,120 @@
+import Property from "./Property";
+import defaultAppendToActionPayload from "./defaultAppendToActionPayload";
+import IProperties from "./interfaces/IProperties";
+import Validator from "./interfaces/IValidator";
+
+function shallowCompare(a, b) {
+  if (typeof a !== "object" || typeof b !== "object") {
+    return a === b;
+  }
+  for (var key in a) {
+    if (!(key in b) || a[key] !== b[key]) {
+      return false;
+    }
+  }
+  for (var key in b) {
+    if (!(key in a) || a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+let count = 0;
+export default class Properties implements IProperties {
+  private data: Map<string, Property>;
+  constructor(properties, private componentName) {
+    this.data = properties;
+    this.data.set(
+      "appendToActionPayload",
+      new Property(defaultAppendToActionPayload)
+    );
+  }
+  public getAllPropertiesValue() {
+    const convertedObject: { [key: string]: any } = {};
+
+    for (const [key, value] of this.data.entries()) {
+      convertedObject[key] = value.getValue();
+    }
+    return convertedObject;
+  }
+  /* break value object*/
+  public updateAllPropertiesValue(validator, propertyValue) {
+    this.validateProperties(validator, propertyValue);
+
+    if (!this.isEqual(propertyValue)) {
+      let isChanged = false;
+
+      Object.keys(propertyValue).forEach((key) => {
+        let property = this.findProperty(key);
+        // if (property) {
+        //   let newProperty = property.clone();
+        //   newProperty.updateValue(propertyValue[key]);
+        //   this.data.set(key, newProperty);
+        // }
+        count++;
+        if (property.getValue() == null || property.getValue() == undefined) {
+          // console.log("key-->", key, property.getValue());
+          property.updateValue(propertyValue[key]);
+          isChanged = true;
+        } else if (property.getValue() != propertyValue[key]) {
+          // console.log("test--->", property.getValue(), propertyValue[key]);
+          property.updateValue(propertyValue[key]);
+          isChanged = true;
+        } else {
+          // console.log("same");
+        }
+      });
+      return isChanged;
+    }
+    // console.log("count", count);
+    return false;
+  }
+  private isEqual(newProps, isShallow = true) {
+    if (isShallow) {
+      return this.shallowCompareWithNewObject(newProps);
+    }
+    return false;
+  }
+  public validateProperties(validator, newProps) {
+    // return true;
+    let errors: Array<object> = [];
+
+    Object.keys(newProps).forEach((key) => {
+      if (!this.data.has(key)) {
+        throw new Error(`props '${key}' not exist `);
+      }
+      let property = this.data.get(key);
+      let schema = property.getTypeMetadata().schema;
+      let isValid = validator(schema, newProps[key]);
+      if (!isValid) {
+        const error = {
+          key: key,
+          componentName: this.componentName,
+          value: newProps[key],
+          schema: schema
+        }
+        errors.push(error);
+      }
+    });
+    if (errors.length > 0) {
+      console.log("Property validation failed", this.componentName, errors);
+      throw new Error("Property validation failed ");
+    }
+    return true;
+  }
+  public findProperty(key) {
+    return this.data.get(key);
+  }
+  public getAppendToActionPayloadProperty() {
+    return this.data.get("appendToActionPayload").getValue();
+  }
+  private shallowCompareWithNewObject(obj1) {
+    const keys1 = Object.keys(obj1);
+    for (let key of keys1) {
+      if (!this.data.has(key) || obj1[key] !== this.data.get(key).getValue()) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

package/src/library/custom-component/entities/Property.ts

@@ -0,0 +1,42 @@
+import IProperty from "./interfaces/IProperty";
+
+export default class Property implements IProperty {
+  private name: string;
+  private required: boolean;
+  private defaultValue: any;
+  private typeMetadata: { schema: JSON };
+  private value: any;
+  constructor({ name, defaultValue, required, typeMetadata }) {
+    this.name = name;
+    this.defaultValue = defaultValue;
+    this.required = required;
+    this.typeMetadata = typeMetadata;
+  }
+  getRequired(): boolean {
+    return this.required;
+  }
+  getName(): string {
+    return this.name;
+  }
+  getDefaultValue(): string {
+    return this.defaultValue;
+  }
+  getTypeMetadata() {
+    return this.typeMetadata;
+  }
+  getValue() {
+    return this.value == undefined ? this.defaultValue : this.value;
+  }
+  /* break value object*/
+  updateValue(value) {
+    this.value = value;
+  }
+  clone(): Property {
+    return new Property({
+      name: this.name,
+      defaultValue: this.defaultValue,
+      required: this.required,
+      typeMetadata: this.typeMetadata
+    });
+  }
+}

package/src/library/custom-component/entities/Schema.ts

@@ -0,0 +1,10 @@
+import ISchema from "./interfaces/ISchema";
+
+class Schema implements ISchema {
+  private _type;
+  constructor() {}
+  getType() {
+    return this._type;
+  }
+}
+export default Schema;

package/src/library/custom-component/entities/State.ts

@@ -0,0 +1,15 @@
+import IState from "./interfaces/IState";
+
+export default class State implements IState {
+  state: any;
+  constructor() {
+    this.state = {};
+  }
+  public getState(): any {
+    return this.state;
+  }
+  /* break value object*/
+  public updateState(state: any): any {
+    this.state = { ...this.state, ...state };
+  }
+}

package/src/library/custom-component/entities/Style.ts

@@ -0,0 +1,25 @@
+import IStyle from "./interfaces/IStyle";
+
+export default class Style implements IStyle {
+  name: string;
+  label: string;
+  required: boolean;
+  defaultValue: any;
+  typeMetadata: { schema: object };
+
+  getLabel(): string {
+    return this.label;
+  }
+  getRequired(): boolean {
+    return this.required;
+  }
+  getName(): string {
+    return this.name;
+  }
+  getDefaultValue(): string {
+    return this.defaultValue;
+  }
+  getTypeMetadata() {
+    return this.typeMetadata;
+  }
+}

package/src/library/custom-component/entities/__tests__/Action.spec.ts

@@ -0,0 +1,22 @@
+import Action from "../../../../../es/library/custom-component/entities/Action";
+import IPayload from "./interfaces/IPayload";
+
+describe("Action", () => {
+  const type = "TEST_ACTION";
+  const payload: IPayload = { data: "test" };
+
+  it("should create an Action instance", () => {
+    const action = new Action(type, payload);
+    expect(action).toBeInstanceOf(Action);
+  });
+
+  it("should have the correct type", () => {
+    const action = new Action(type, payload);
+    expect(action.getType()).toBe(type);
+  });
+
+  it("should have the correct payload", () => {
+    const action = new Action(type, payload);
+    expect(action.getPayload()).toEqual(payload);
+  });
+});

package/src/library/custom-component/entities/__tests__/ActionHandlers.spec.ts

@@ -0,0 +1,19 @@
+import ActionHandlers from '../../../../../es/library/custom-component/entities/ActionHandlers';
+
+describe('ActionHandlers', () => {
+  it('should create an ActionHandlers instance with provided handlers', () => {
+    // Define sample handlers
+    const handlers = new Map<string, Function>();
+    handlers.set('ACTION_1', jest.fn());
+    handlers.set('ACTION_2', jest.fn());
+
+    // Create an instance of ActionHandlers
+    const actionHandlers = new ActionHandlers(handlers);
+
+    // Verify that the instance is created successfully
+    expect(actionHandlers).toBeInstanceOf(ActionHandlers);
+
+    // Verify that the provided handlers are stored correctly
+    expect(actionHandlers.getEventHandlers()).toEqual(handlers);
+  });
+});

package/src/library/custom-component/entities/__tests__/Behaviour.spec.ts

@@ -0,0 +1,56 @@
+import Behaviour from "../../../../../es/library/custom-component/entities/Behaviour";
+import IProperties from "./interfaces/IProperties";
+import IActionHandlers from "./interfaces/IActionHandlers";
+
+describe("Behaviour", () => {
+  const name = "TestBehaviour";
+  const properties: IProperties = {
+    getAllPropertiesValue: jest.fn().mockReturnValue({})
+  };
+  const setInitialState = jest.fn();
+  const actionHandlers: IActionHandlers = {
+    getEventHandlers: jest.fn().mockReturnValue(new Map())
+  };
+
+  it("should create a Behaviour instance with provided parameters", () => {
+    const behaviour = new Behaviour({
+      name,
+      properties,
+      setIntialState: setInitialState,
+      actionHandlers
+    });
+
+    expect(behaviour).toBeInstanceOf(Behaviour);
+    expect(behaviour.getName()).toBe(name);
+    expect(behaviour.getProperties()).toBe(properties);
+    expect(behaviour.getEventHandlers()).toBe(actionHandlers);
+  });
+
+  it("should return initial state with setInitialState function", () => {
+    const initialState = { test: "initialState" };
+    setInitialState.mockReturnValue(initialState);
+
+    const behaviour = new Behaviour({
+      name,
+      properties,
+      setIntialState: setInitialState,
+      actionHandlers
+    });
+
+    expect(behaviour.getInitialState()).toEqual({ [name]: initialState });
+    expect(setInitialState).toHaveBeenCalledWith({
+      properties: properties.getAllPropertiesValue()
+    });
+  });
+
+  it("should return empty initial state if setInitialState function is not provided", () => {
+    const behaviour = new Behaviour({
+      name,
+      properties,
+      setIntialState: undefined,
+      actionHandlers
+    });
+
+    expect(behaviour.getInitialState()).toEqual({ [name]: {} });
+  });
+});

package/src/library/custom-component/entities/__tests__/Component.spec.ts

@@ -0,0 +1,105 @@
+import ComponentFactory from "../../../../../es/library/custom-component/usecases/entities-factory/ComponentFactory";
+
+describe("Component", () => {
+  let component;
+  let properties;
+  let lifeCycleAction;
+  let actionHandlers;
+  let behaviour;
+  let jsonValidator;
+  beforeEach(() => {
+    // Create Component instance
+    jsonValidator = jest.fn().mockReturnValue(true);
+    component = ComponentFactory({
+      name: "TestComponent",
+      properties: {
+        text: {
+          required: true,
+          typeMetadata: {
+            schema: {
+              type: "string"
+            }
+          }
+        },
+        color: {
+          required: true,
+          typeMetadata: {
+            schema: {
+              type: "string"
+            }
+          }
+        },
+        tooltip: {
+          required: true,
+          defaultValue: "",
+          typeMetadata: {
+            schema: {
+              type: "string"
+            }
+          }
+        }
+      },
+      actions: [
+        {
+          type: "TEXT#CLICKED"
+        }
+      ],
+      actionHandlers: {
+        "TEXT#CLICKED": jest.fn()
+      },
+      behaviours: []
+    });
+  });
+
+  describe("Initialization", () => {
+    it("should initialize component properties and state", () => {
+      const newProps = { text: "welcome", color: "red" };
+
+      component.init(jsonValidator, newProps);
+
+      expect(component.getState()).toEqual({
+        properties: {
+          color: "red",
+          text: "welcome",
+          tooltip: "",
+          appendToActionPayload: null
+        }
+      });
+    });
+  });
+
+  describe.only("State and Properties", () => {
+    it("should update properties", () => {
+      const initialProps = { text: "welcome", color: "red" };
+      component.init(jsonValidator, initialProps);
+      const newProps = { text: "welcome friend", color: "yellow" };
+      component.updateProperties(jsonValidator, newProps);
+      expect(component.getState()).toEqual({
+        properties: {
+          color: "yellow",
+          text: "welcome friend",
+          tooltip: "",
+          appendToActionPayload: null
+        }
+      });
+    });
+
+    it("should update state", () => {
+      const initialProps = { text: "welcome", color: "red" };
+      component.init(jsonValidator, initialProps);
+      const newState = { test: "state" };
+
+      component.updateState(newState);
+
+      expect(component.getState()).toEqual({
+        properties: {
+          color: "red",
+          text: "welcome",
+          tooltip: "",
+          appendToActionPayload: null
+        },
+        test: "state"
+      });
+    });
+  });
+});

package/src/library/custom-component/entities/defaultAppendToActionPayload.ts

@@ -0,0 +1,10 @@
+export default {
+  name: "appendToActionPayload",
+  required: false,
+  defaultValue: null,
+  typeMetadata: {
+    schema: {
+      type: "object"
+    }
+  }
+};

package/src/library/custom-component/entities/interfaces/IBehaviour.ts

@@ -0,0 +1,11 @@
+import setInitialState from "../../../../cc/component/setInitialState";
+import IActionHandlers from "./IActionHandlers";
+import IProperties from "./IProperties";
+
+interface IBehaviour {
+  getName(): string;
+  getProperties(): IProperties;
+  getInitialState(): object;
+  getEventHandlers(): IActionHandlers;
+}
+export default IBehaviour;

package/src/library/custom-component/entities/interfaces/IComponent.ts

@@ -0,0 +1,37 @@
+import IAction from "./IAction";
+import {
+  MountType,
+  UnMountType,
+  UpdatePropertiesType
+} from "./ILifeCycleAction";
+import IProperties from "./IProperties";
+import IValidator from "./IValidator";
+
+interface IComponent {
+  getState: () => any;
+  setProperties: (properties: IProperties) => void;
+  setEvents: (events: Array<IAction>) => void;
+  updateProperties: (validator: IValidator, newProps: any) => boolean;
+  init: (validator: IValidator, newProps: any) => void;
+  updateState: (state: any) => void;
+  getEventHandlersWrapper: () => Map<string, Array<Function>>;
+  createEventHandlers: (helpers: any) => void;
+  getMountAction: () => {
+    type: MountType;
+    eventObject: any;
+  };
+  getUnmountAction: () => {
+    type: UnMountType;
+    eventObject: any;
+  };
+  getProperties: () => { [key: string]: any };
+  getPropertyUpdateAction: (payload: any) => {
+    type: UpdatePropertiesType;
+    eventObject: any;
+  };
+  constructAction: (action: any) => {
+    type: UpdatePropertiesType;
+    eventObject: any;
+  };
+}
+export default IComponent;

package/src/library/custom-component/entities/interfaces/IEvent.ts

@@ -0,0 +1,7 @@
+import IPayload from "./IPayload";
+
+interface IEvent {
+  getType(): string;
+  getPayload(): IPayload;
+}
+export default IEvent;

package/src/library/custom-component/entities/interfaces/IEventHandler.ts

@@ -0,0 +1,5 @@
+import IEvent from "./IEvent";
+import IEventHandlerHelpers from "./IEventHandlerHelpers";
+
+type IEventHandler = (action: IEvent, utils: IEventHandlerHelpers) => void;
+export default IEventHandler;

package/src/library/custom-component/entities/interfaces/IEventHandlerHelpers.ts

@@ -0,0 +1,7 @@
+type IEventHandlerHelpers = {
+  state: any;
+  updateState: Function;
+  properties: any;
+  updateProperties: Function;
+};
+export default IEventHandlerHelpers;

package/src/library/custom-component/entities/interfaces/IEventHandlers.ts

@@ -0,0 +1,4 @@
+interface IEventHandlers {
+  getEventHandlers: () => Map<string, Function>;
+}
+export default IEventHandlers;

package/src/library/custom-component/entities/interfaces/IEventWrapper.ts

@@ -0,0 +1,5 @@
+interface IEventWrapper {
+    getEventHandler: () => Function;
+  }
+  export default IEventWrapper;
+  

package/src/library/custom-component/entities/interfaces/ILifeCycleAction.ts

@@ -0,0 +1,19 @@
+export type MountType = `${string}#MOUNT`;
+export type UnMountType = `${string}#UN_MOUNT`;
+export type UpdatePropertiesType = `${string}#UPDATE_PROPERTIES`;
+
+interface ILifeCycleAction {
+  getMountAction: () => {
+    type: MountType;
+    eventObject: any;
+  };
+  getUnmountAction: () => {
+    type: UnMountType;
+    eventObject: any;
+  };
+  getUpdatePropertiesAction: (payload: any) => {
+    type: UpdatePropertiesType;
+    eventObject: any;
+  };
+}
+export default ILifeCycleAction;

package/src/library/custom-component/entities/interfaces/IPayload.ts

@@ -0,0 +1,5 @@
+interface IPayload {
+  getName: () => string;
+  getTypeMetadata: () => any;
+}
+export default IPayload;

package/src/library/custom-component/entities/interfaces/IProperties.ts

@@ -0,0 +1,12 @@
+import IValidator from "./IValidator";
+
+interface IProperties {
+  getAllPropertiesValue(): { [key: string]: any };
+  validateProperties(validator, newProps): boolean;
+  updateAllPropertiesValue: (
+    validator: IValidator,
+    propertyValue: { [key: string]: any }
+  ) => boolean;
+  getAppendToActionPayloadProperty: () => any;
+}
+export default IProperties;

package/src/library/custom-component/entities/interfaces/IProperty.ts

@@ -0,0 +1,9 @@
+interface IProperty {
+  getRequired(): boolean;
+  getName(): string;
+  getDefaultValue(): string;
+  getValue(): any;
+  getTypeMetadata(): { schema: JSON };
+  updateValue(value): void;
+}
+export default IProperty;

package/src/library/custom-component/entities/interfaces/ISchema.ts

@@ -0,0 +1,4 @@
+interface ISchema {
+  getType: () => JSON;
+}
+export default ISchema;

package/src/library/custom-component/entities/interfaces/IState.ts

@@ -0,0 +1,5 @@
+interface IState {
+  getState: () => any;
+  updateState: (state: any) => any;
+}
+export default IState;

package/src/library/custom-component/entities/interfaces/IStyle.ts

@@ -0,0 +1,8 @@
+interface IStyle {
+  getLabel(): string;
+  getRequired(): boolean;
+  getName(): string;
+  getDefaultValue(): string;
+  getTypeMetadata(): any;
+}
+export default IStyle;