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

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

@@ -5,4 +5,4 @@ export declare function buildApiPayload(compConfig: any, body: any, headers: any
     body: any;
     headers: any;
 }>;
-export declare function getRefreshElements(eventConfig: any, eventGroups: any): string[];
+export declare function getRefreshElements(eventConfig: any, eventGropus: any): string[];

package/package.json

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

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

@@ -1,103 +1,77 @@
 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 };
     }
-
-    // Execute the event handler and get the response
-    const response = await executeEventsHandler(params);
+    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) {
-    // Handle failure events
-    const FailEvent = params.config?.events?.filter(e => e.eventType === "Fail");
-    const setEvent = FailEvent?.length > 0 ? FailEvent : [];
+    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) {
-      const result = await executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse });
-      accumulatedData = { ...accumulatedData, ...result };
+      await executeEvents({ ...params, config: actionConfig, parentEventOutput: 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);
-    return res;
-  } 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);
-    return res;
-  } 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();
+    return await executeApiEventHandler(params)
+  }
+  else if (params.config.Handler === "inBuiltFunction") {
+    return await executeInBuiltFunctionHandler(params)
+  }
+  else if (params.config.Handler === "custom") {
+    return await executeCustomHandler(params)
+  }
+  else if (params.config.Handler === "refresh") {
+    return await executeRefreshHandler(params)
+  }
+  else if (params.config.Handler === "mergeFormdata") {
+    const result = await mergeFormdata(
+      params.parentEventOutput, params.componentName, params.config, params.store, params.service)
+    return result;
+  }
+  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,
@@ -107,65 +81,62 @@ 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;
 }
 
-// Function to merge form data
-async function mergeFormdata(
-  handlerResponse: any,
-  componentName: string,
-  eventConfig: any,
-  store: any,
-  service: any
-) {
-  let accumulatedData = {};
-
+async function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, service: any) {
   if (eventConfig.type === "Select" && !(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
-    accumulatedData = {
-      [componentName]: {
-        ...store.schema.properties?.[componentName],
-        oneOf: handlerResponse.data
+    store.setSchema((pre) => {
+      return {
+        ...pre, properties: {
+          ...pre.properties, [componentName]: {
+            ...pre.properties?.[componentName],
+            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 === "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 === "page") {
+    })
+  }
+  else if (eventConfig.type === "page") {
     if (!(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
-      accumulatedData = { ...handlerResponse?.data };
+      store.setFormdata((pre: any) => { return { ...pre, ...handlerResponse?.data } })
     }
-  } else {
+  }
+  else {
     if (handlerResponse) {
-      accumulatedData = { [componentName]: eventConfig.lazyLoading ? handlerResponse.data.data : handlerResponse.data };
+      store.setFormdata((pre) => { return { ...pre, [componentName]: eventConfig.lazyLoading ? handlerResponse.data.data : handlerResponse.data } });
+      const demoData = await asyncOperation();
     }
   }
-
-  // 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) => {
@@ -174,16 +145,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;
 }
 
@@ -191,28 +162,27 @@ 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) };
@@ -220,19 +190,21 @@ 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 };
 }
 
-// Function to get elements that need refreshing
-export function getRefreshElements(eventConfig: any, eventGroups: any) {
+export function getRefreshElements(eventConfig: any, eventGropus: any) {
   let result: string[] = [];
   if (eventConfig?.refreshElements?.length > 0) {
-    result = eventConfig.refreshElements.map((e) => e.value);
+    result = eventConfig.refreshElements.map((e) => {
+      return e.value
+    })
+
   } else {
-    if (eventGroups?.onLoad) {
-      result = Object.keys(eventGroups?.onLoad);
+    if (eventGropus?.onLoad) {
+      result = Object.keys(eventGropus?.onLoad)
       result.push(result[0]);
     }
   }
@@ -240,16 +212,15 @@ export function getRefreshElements(eventConfig: any, eventGroups: 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);
   });
-}
+}

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

@@ -229,11 +229,12 @@ export default (funcParams: funcParamsProps) => {
       if (eventGroups?.[eventType]?.[path] !== undefined) {
         for (const eventConfig of eventGroups?.[eventType]?.[path]) {
           executeEventsParameters.store.functionParameters = functionParameters
-          await executeEvents({
+          const res = await executeEvents({
             ...executeEventsParameters,
             config: eventConfig,
             componentName: path
           })
+          console.log("valll", res);
         }
       }
     },