impaktapps-ui-builder 0.0.382-alpha.334 → 0.0.382-alpha.335

package/dist/src/impaktapps-ui-builder/runtime/services/events.d.ts

@@ -1,11 +1,8 @@
 import { handlersProps } from "./interface";
-export declare const executeEvents: (params: handlersProps) => Promise<{
-    response: any;
-    events: any;
-}>;
+export declare const executeEvents: (params: handlersProps) => Promise<any>;
 export declare function executeRefreshHandler(params: handlersProps): Promise<void>;
 export declare function buildApiPayload(compConfig: any, body: any, headers: any, store: any, dynamicData: any, userValue: any, service: any): Promise<{
     body: any;
     headers: any;
 }>;
-export declare function getRefreshElements(eventConfig: any, eventGropus: any): string[];
+export declare function getRefreshElements(eventConfig: any, eventGroups: any): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "impaktapps-ui-builder",
-    "version": "0.0.382-alpha.334",
+    "version": "0.0.382-alpha.335",
     "scripts": {
         "dev": "vite",
         "build": "tsc && vite build",

package/src/impaktapps-ui-builder/runtime/services/events.ts

@@ -1,85 +1,103 @@
 import _, { cloneDeep } from "lodash";
 import { handlersProps } from "./interface";
 
-
+// Main function to execute events
 export const executeEvents = async (
   params: handlersProps
 ) => {
   let nextEvent = [];
   let finalResponse = null;
+  let accumulatedData = {}; // Accumulated data variable
+
   try {
-    const shouldExecute = await shouldEventExecute(params)
+    const shouldExecute = await shouldEventExecute(params);
     if (!shouldExecute) {
       return { response: undefined, events: undefined };
     }
-    const response = await executeEventsHandler(params)
+
+    // Execute the event handler and get the response
+    const response = await executeEventsHandler(params);
     finalResponse = response;
+
+    // Check if we need to accumulate data from mergeFormdata handler
+    if (params.config.Handler === "mergeFormdata") {
+      const data = await mergeFormdata(
+        params.parentEventOutput,
+        params.componentName,
+        params.config,
+        params.store,
+        params.service
+      );
+      accumulatedData = { ...accumulatedData, ...data };
+    }
+
+    // Filter events to execute based on success
     const SuccessEvent = params.config?.events.filter(e => e.eventType === "Success");
     nextEvent = SuccessEvent;
   } catch (err) {
-    const FailEvent = params.config?.events?.filter(e => e.eventType === "Fail")
-    const setEvent = FailEvent?.length > 0 ? FailEvent : []
+    // Handle failure events
+    const FailEvent = params.config?.events?.filter(e => e.eventType === "Fail");
+    const setEvent = FailEvent?.length > 0 ? FailEvent : [];
     nextEvent = setEvent;
   }
+
+  // Execute the next events
   if (nextEvent?.length > 0) {
     for (const actionConfig of nextEvent) {
-      await executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse })
+      const result = await executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse });
+      accumulatedData = { ...accumulatedData, ...result };
     }
   }
-   finalResponse;
+
+  // After all events are processed, update the store with accumulated data
+  params.store.setFormdata((pre: any) => ({ ...pre, ...accumulatedData }));
+
+  return finalResponse;
 }
 
+// Handler function execution
 async function executeEventsHandler(params: handlersProps) {
   if (params.config.Handler === "api") {
-    const res = await executeApiEventHandler(params)
-    const demoData = await asyncOperation();
+    const res = await executeApiEventHandler(params);
     return res;
-  }
-  else if (params.config.Handler === "inBuiltFunction") {
-    return await executeInBuiltFunctionHandler(params)
-  }
-  else if (params.config.Handler === "custom") {
-    const res =  await executeCustomHandler(params)
-    const demoData = await asyncOperation();
+  } else if (params.config.Handler === "inBuiltFunction") {
+    return await executeInBuiltFunctionHandler(params);
+  } else if (params.config.Handler === "custom") {
+    const res = await executeCustomHandler(params);
     return res;
-  }
-  else if (params.config.Handler === "refresh") {
-    const res =  await executeRefreshHandler(params)
-    const demoData = await asyncOperation();
-    return res;
-  }
-  else if (params.config.Handler === "mergeFormdata") {
-    const result = await mergeFormdata(
-      params.parentEventOutput, params.componentName, params.config, params.store, params.service)
-    const res =  result;
-    const demoData = await asyncOperation();
+  } else if (params.config.Handler === "refresh") {
+    const res = await executeRefreshHandler(params);
     return res;
-  }
-  else if (params.config.Handler === "onBackHandler") {
-    return params.store.functionParameters?.handleBack()
-  }
-  else if (params.config.Handler === "onNextHandler") {
-    return params.store.functionParameters?.handleNext()
-  }
-  else if (params.config.Handler === "onResetHandler") {
-    return params.store.functionParameters?.handleReset()
+  } else if (params.config.Handler === "mergeFormdata") {
+    // Don't call mergeFormdata here. It's already handled in executeEvents.
+    return params.parentEventOutput;
+  } else if (params.config.Handler === "onBackHandler") {
+    return params.store.functionParameters?.handleBack();
+  } else if (params.config.Handler === "onNextHandler") {
+    return params.store.functionParameters?.handleNext();
+  } else if (params.config.Handler === "onResetHandler") {
+    return params.store.functionParameters?.handleReset();
   }
 }
+
+// Refresh handler function
 export async function executeRefreshHandler(params: handlersProps) {
-  const compToRefresh: string[] = getRefreshElements(params.config, params.eventGroups)
+  const compToRefresh: string[] = getRefreshElements(params.config, params.eventGroups);
   for (const componentName of compToRefresh) {
     for (const compEventConfig of params.eventGroups.onLoad[componentName]) {
       await executeEvents({ ...params, config: compEventConfig, componentName });
     }
   }
 }
+
+// API event handler function
 async function executeApiEventHandler(params: handlersProps) {
   const initialBody = { ...params.userValue?.payload };
   const initialHeaders = {
     "X-Requested-With": "XMLHttpRequest",
     "Access-Control-Allow-Origin": "*"
   };
-  const { body, headers } = await buildApiPayload(params.config, initialBody, initialHeaders, params.store, params.dynamicData, params.userValue, params.service)
+  const { body, headers } = await buildApiPayload(params.config, initialBody, initialHeaders, params.store, params.dynamicData, params.userValue, params.service);
 
   const response = await params.service[params.config.method](
     params.config.path,
@@ -89,63 +107,65 @@ async function executeApiEventHandler(params: handlersProps) {
   return response;
 }
 
+// Built-in function event handler
 async function executeInBuiltFunctionHandler(params: handlersProps) {
   let parameter = {};
   if (params.config.funcParametersCode) {
-    const makeFunc = eval(params.config.funcParametersCode)
+    const makeFunc = eval(params.config.funcParametersCode);
     parameter = makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service);
   }
-  params.serviceHolder[params.config.inBuiltFunctionType](parameter)
+  params.serviceHolder[params.config.inBuiltFunctionType](parameter);
 }
 
+// Custom handler function
 async function executeCustomHandler(params: handlersProps) {
-  const makeFunc = eval(params.config.eventCode)
+  const makeFunc = eval(params.config.eventCode);
   const response = await makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service, params.componentName);
   return response;
 }
 
-async function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, service: any) {
+// Function to merge form data
+async function mergeFormdata(
+  handlerResponse: any,
+  componentName: string,
+  eventConfig: any,
+  store: any,
+  service: any
+) {
+  let accumulatedData = {};
+
   if (eventConfig.type === "Select" && !(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
-    store.setSchema((pre) => {
-      return {
-        ...pre, properties: {
-          ...pre.properties, [componentName]: {
-            ...pre.properties?.[componentName],
-            oneOf: handlerResponse.data
-          }
-        }
+    accumulatedData = {
+      [componentName]: {
+        ...store.schema.properties?.[componentName],
+        oneOf: handlerResponse.data
       }
-    })
-  }
-  else if (eventConfig.type === "MultipleSelect" && !(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
-    store.setSchema((pre) => {
-      return {
-        ...pre, properties: {
-          ...pre.properties, [componentName]: {
-            ...pre.properties?.[componentName],
-            type: "array",
-            items: {
-              oneOf: handlerResponse?.data
-            }
-          }
+    };
+  } else if (eventConfig.type === "MultipleSelect" && !(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
+    accumulatedData = {
+      [componentName]: {
+        ...store.schema.properties?.[componentName],
+        type: "array",
+        items: {
+          oneOf: handlerResponse?.data
         }
       }
-    })
-  }
-  else if (eventConfig.type === "page") {
+    };
+  } else if (eventConfig.type === "page") {
     if (!(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
-      store.setFormdata((pre: any) => { return { ...pre, ...handlerResponse?.data } })
-      const demoData = await asyncOperation();
+      accumulatedData = { ...handlerResponse?.data };
     }
-  }
-  else {
+  } else {
     if (handlerResponse) {
-      store.setFormdata((pre) => { return { ...pre, [componentName]: eventConfig.lazyLoading ? handlerResponse.data.data : handlerResponse.data } });
-      const demoData = await asyncOperation();
+      accumulatedData = { [componentName]: eventConfig.lazyLoading ? handlerResponse.data.data : handlerResponse.data };
     }
   }
+
+  // Return accumulated data
+  return accumulatedData;
 }
 
+// Helper functions for building API payloads
 const buildBodyFormat = (body: any[], formData: any, userValue: any) => {
   const finalBody = { ...userValue?.payload };
   body.map((elem) => {
@@ -154,16 +174,16 @@ const buildBodyFormat = (body: any[], formData: any, userValue: any) => {
     } else {
       if (elem?.value?.startsWith("$userValue")) {
         const finalpath = elem.value.substring(11);
-        finalBody[elem.key] = _.get(userValue, finalpath);;
+        finalBody[elem.key] = _.get(userValue, finalpath);
       }
       else if (elem?.value?.startsWith("$")) {
         const finalpath = elem.value.substring(1);
-        finalBody[elem.key] = _.get(formData, finalpath);;
+        finalBody[elem.key] = _.get(formData, finalpath);
       } else {
         finalBody[elem.key] = elem.value;
       }
     }
-  })
+  });
   return finalBody;
 }
 
@@ -171,27 +191,28 @@ const buildHeadersFormat = (headers: any[]) => {
   const headerObj = {
     // "Content-Type": "application/json",
     "X-Requested-With": "XMLHttpRequest"
-  }
+  };
   headers.map((elem) => {
     headerObj[elem.key] = elem.value;
-  })
+  });
   return headerObj;
 }
 
+// Function to determine if an event should execute
 async function shouldEventExecute(params: handlersProps) {
   const startEvent = params.config?.events?.filter(e => e.eventType === "onStart");
   if (startEvent?.length > 0) {
     const response = await executeEventsHandler({ ...params, config: startEvent[0] });
     return response;
   } else {
-    return true
+    return true;
   }
 }
 
+// Function to build API payload
 export async function buildApiPayload(compConfig: any, body: any, headers: any, store: any, dynamicData: any, userValue: any, service) {
   if (compConfig?.headers) {
-    headers = buildHeadersFormat(compConfig.headers)
-
+    headers = buildHeadersFormat(compConfig.headers);
   }
   if (compConfig.body) {
     body = { ...buildBodyFormat(compConfig.body, store.newData || store?.ctx?.core?.data || store.formData, userValue) };
@@ -199,21 +220,19 @@ export async function buildApiPayload(compConfig: any, body: any, headers: any,
   if (compConfig.apiBody) {
     const makeFunc = eval(compConfig.apiBody);
     const data = await makeFunc(store, dynamicData, userValue, body);
-    body = data
+    body = data;
   }
   return { body, headers };
 }
 
-export function getRefreshElements(eventConfig: any, eventGropus: any) {
+// Function to get elements that need refreshing
+export function getRefreshElements(eventConfig: any, eventGroups: any) {
   let result: string[] = [];
   if (eventConfig?.refreshElements?.length > 0) {
-    result = eventConfig.refreshElements.map((e) => {
-      return e.value
-    })
-
+    result = eventConfig.refreshElements.map((e) => e.value);
   } else {
-    if (eventGropus?.onLoad) {
-      result = Object.keys(eventGropus?.onLoad)
+    if (eventGroups?.onLoad) {
+      result = Object.keys(eventGroups?.onLoad);
       result.push(result[0]);
     }
   }
@@ -221,15 +240,16 @@ export function getRefreshElements(eventConfig: any, eventGropus: any) {
   return result;
 }
 
-
+// Mock asynchronous operation
 function asyncOperation() {
   return new Promise((resolve, reject) => {
     setTimeout(() => {
       const success = true;
       if (success) {
         resolve("Operation completed successfully!");
+      } else {
         reject(new Error("Operation failed!"));
       }
     }, 50);
   });
-}
+}