@xuda.io/runtime-bundle 1.0.319 → 1.0.320

package/js/xuda-runtime-slim.js

@@ -6379,7 +6379,7 @@ func.utils.job_worker = function (session_id) {
                 val.containerP,
                 val.elementP,
                 val.rowP,
-                null,
+                val.evt,
                 val.descP,
                 val.rootScreenIdP,
                 val.dsSessionP,
@@ -9303,15 +9303,7 @@ func.UI.garbage_collector = function (
 };
 
  func.events = {};
-func.events.validate = async function (
-  SESSION_ID,
-  triggerP,
-  dsSessionP,
-  eventIdP,
-  sourceP,
-  argumentsP,
-  return_validation_onlyP
-) {
+func.events.validate = async function (SESSION_ID, triggerP, dsSessionP, eventIdP, sourceP, argumentsP, return_validation_onlyP) {
   var _session = SESSION_OBJ[SESSION_ID];
   var _ds = _session.DS_GLB[dsSessionP];
   var args = {
@@ -9324,16 +9316,8 @@ func.events.validate = async function (
     return_validation_onlyP,
   };
   const search_event_in_parent_ds = async function () {
-    if (_ds && typeof _ds.parentDataSourceNo !== "undefined") {
-      await func.events.validate(
-        SESSION_ID,
-        triggerP,
-        _ds.parentDataSourceNo,
-        eventIdP,
-        sourceP,
-        argumentsP,
-        return_validation_onlyP
-      );
+    if (_ds && typeof _ds.parentDataSourceNo !== 'undefined') {
+      await func.events.validate(SESSION_ID, triggerP, _ds.parentDataSourceNo, eventIdP, sourceP, argumentsP, return_validation_onlyP);
     }
   };
   var ret = false;
@@ -9355,29 +9339,13 @@ func.events.validate = async function (
         var eventProp = undefined;
         if (val.data.type === triggerP) {
           // compare event trigger
-          if (
-            (triggerP !== "user_defined") |
-            (triggerP === "user_defined" && eventIdP === val.data.event_name)
-          ) {
+          if ((triggerP !== 'user_defined') | (triggerP === 'user_defined' && eventIdP === val.data.event_name)) {
             // compare user defined name
 
             var expCond;
-            if (val.data.condition)
-              expCond = await func.expression.get(
-                SESSION_ID,
-                val.data.condition,
-                dsSessionP,
-                "condition"
-              );
+            if (val.data.condition) expCond = await func.expression.get(SESSION_ID, val.data.condition, dsSessionP, 'condition');
             if (!val.data.condition || expCond.result) {
-              func.utils.debug.watch(
-                SESSION_ID,
-                _ds.prog_id + "%" + val.id,
-                "view_event",
-                val,
-                triggerP + " " + eventIdP,
-                expCond
-              );
+              func.utils.debug.watch(SESSION_ID, _ds.prog_id + '%' + val.id, 'view_event', val, triggerP + ' ' + eventIdP, expCond);
               ret = true;
               if (return_validation_onlyP) break;
               const set_arguments = async function () {
@@ -9415,48 +9383,24 @@ func.events.validate = async function (
                 //   await func.datasource.update(SESSION_ID, datasource_changes);
                 // }
 
-                for await (let [key, fieldId] of Object.entries(
-                  val.data.parameters
-                )) {
-                  const field_info = func.common.find_item_by_key(
-                    _view_obj.progFields,
-                    "field_id",
-                    fieldId
-                  );
+                for await (let [key, fieldId] of Object.entries(val.data.parameters)) {
+                  const field_info = func.common.find_item_by_key(_view_obj.progFields, 'field_id', fieldId);
 
-                  if (field_info?.data?.type !== "virtual") {
-                    console.warn("parameter field must be virtual, update ignored");
+                  if (field_info?.data?.type !== 'virtual') {
+                    console.warn('parameter field must be virtual, update ignored');
                     continue;
                   }
 
-                  if (!args[fieldId]) continue
-
+                  if (!args[fieldId]) continue;
 
-
-                  let value = await func.common.get_cast_val(
-                    SESSION_ID,
-                    "events",
-                    fieldId,
-                    field_info.props.fieldType,
-                    args[fieldId].value
-                  );
+                  let value = await func.common.get_cast_val(SESSION_ID, 'events', fieldId, field_info.props.fieldType, args[fieldId].value);
 
                   if (!_.isEmpty(args[fieldId].fx)) {
-                    const fx_ret = await func.expression.get(
-                      SESSION_ID,
-                      args[fieldId].fx,
-                      dsSessionP,
-                      "update"
-                    )
+                    const fx_ret = await func.expression.get(SESSION_ID, args[fieldId].fx, dsSessionP, 'update');
                     value = fx_ret.result;
                   }
                   // find the target field in the program dataset
-                  const ret = await func.datasource.get_value(
-                    SESSION_ID,
-                    fieldId,
-                    dsSessionP,
-                    _ds.currentRecordId
-                  );
+                  const ret = await func.datasource.get_value(SESSION_ID, fieldId, dsSessionP, _ds.currentRecordId);
 
                   const datasource_changes = {
                     [ret.dsSessionP]: {
@@ -9469,11 +9413,7 @@ func.events.validate = async function (
                 await add_event();
               };
               const add_event = async function () {
-                const _event = func.common.find_item_by_key_root(
-                  _view_obj.progEvents,
-                  "id",
-                  val.id
-                );
+                const _event = func.common.find_item_by_key_root(_view_obj.progEvents, 'id', val.id);
                 if (_event.triggers) {
                   // check if event property exist
 
@@ -9496,22 +9436,19 @@ func.events.validate = async function (
                     if (!glb.IS_WORKER) {
                       if (_ds.panel_div_id) {
                         try {
-                          container = "#" + _ds.panel_div_id;
+                          container = '#' + _ds.panel_div_id;
                           if ($(container).data().xuData.panel_info) {
-                            screen_prop =
-                              $(container).data().xuData.panel_info.paramsP;
+                            screen_prop = $(container).data().xuData.panel_info.paramsP;
                           } else {
                             ///////////////
-                            container =
-                              "#" + _session.DS_GLB[dsSessionP].screenId;
+                            container = '#' + _session.DS_GLB[dsSessionP].screenId;
 
                             if ($(container) && $(container).data()) {
                               screen_prop = $(container).data().xuData.paramsP;
                             }
 
                             if (!$(container) || !$(container).length) {
-                              container =
-                                "#" + _session.DS_GLB[dsSessionP].containerId;
+                              container = '#' + _session.DS_GLB[dsSessionP].containerId;
                             }
                             //////////////
                           }
@@ -9519,14 +9456,14 @@ func.events.validate = async function (
                           console.error(e);
                         }
                       } else {
-                        container = "#" + _ds.screenId;
+                        container = '#' + _ds.screenId;
 
                         if ($(container) && $(container).data()) {
                           screen_prop = $(container).data().xuData.paramsP;
                         }
 
                         if (!$(container) || !$(container).length) {
-                          container = "#" + _ds.containerId;
+                          container = '#' + _ds.containerId;
                         }
                       }
                     } else {
@@ -9538,7 +9475,7 @@ func.events.validate = async function (
                     jobs.push(
                       await func.events.add_to_queue(
                         SESSION_ID,
-                        sourceP + " event",
+                        sourceP + ' event',
                         trigger_obj.id,
                         null, // was click
                         trigger_obj.data.action,
@@ -9564,8 +9501,8 @@ func.events.validate = async function (
                         null,
                         args,
                         null,
-                        null
-                      )
+                        null,
+                      ),
                     );
                   }
                 }
@@ -9577,15 +9514,7 @@ func.events.validate = async function (
               }
             } else {
               if (val.data.condition && !expCond.result) {
-                func.utils.debug.watch(
-                  SESSION_ID,
-                  _ds.prog_id + "%" + val.id,
-                  "view_event",
-                  val,
-                  triggerP + " " + eventIdP,
-                  expCond,
-                  true
-                );
+                func.utils.debug.watch(SESSION_ID, _ds.prog_id + '%' + val.id, 'view_event', val, triggerP + ' ' + eventIdP, expCond, true);
               }
             }
           }
@@ -9608,7 +9537,7 @@ func.events.add_to_queue = async function (
   containerP,
   elementP,
   rowP,
-  NA_colP,
+  evt,
   descP,
   NA_rootScreenIdP,
   NA_callingEventIdP,
@@ -9626,7 +9555,7 @@ func.events.add_to_queue = async function (
   calling_job,
   args,
   $div,
-  $container
+  $container,
 ) {
   var _session = SESSION_OBJ[SESSION_ID];
   var obj = {
@@ -9651,11 +9580,11 @@ func.events.add_to_queue = async function (
     args,
     $div,
     $container,
-
+    evt,
     job_num: _session.WORKER_OBJ.num,
   };
   var _ds = _session.DS_GLB[dsSessionP];
-  if (typeof dsSessionP !== "undefined" && dsSessionP !== null) {
+  if (typeof dsSessionP !== 'undefined' && dsSessionP !== null) {
     obj.prog_id = _ds.prog_id;
     obj.parentDataSourceNo = _ds.parentDataSourceNo;
     obj.nodeId = _ds.nodeId;
@@ -9663,21 +9592,16 @@ func.events.add_to_queue = async function (
   ///////
   if (glb.IS_WORKER && func.utils.is_onscreen_event(functionP)) {
     obj.client = true;
-    if (functionP === "call_library") {
+    if (functionP === 'call_library') {
       obj.client = false;
     }
-    if (typeof dsSessionP !== "undefined" && dsSessionP !== null) {
+    if (typeof dsSessionP !== 'undefined' && dsSessionP !== null) {
       obj.ds_obj = func.utils.clean_returned_datasource(SESSION_ID, dsSessionP);
     }
     if (obj.client) {
       _session.WORKER_OBJ.num++;
       // if (!_session.IS_API)
-      func.utils.post_back_to_client(
-        SESSION_ID,
-        "job",
-        _session.worker_id,
-        obj
-      );
+      func.utils.post_back_to_client(SESSION_ID, 'job', _session.worker_id, obj);
       return;
     }
   }
@@ -9691,14 +9615,10 @@ func.events.add_to_queue = async function (
         _session.WORKER_OBJ.jobs[job_index].splice_count = 0;
       }
       _session.WORKER_OBJ.jobs[job_index].splice_count++;
-      _session.WORKER_OBJ.jobs.splice(
-        job_index + _session.WORKER_OBJ.jobs[job_index].splice_count,
-        0,
-        obj
-      );
+      _session.WORKER_OBJ.jobs.splice(job_index + _session.WORKER_OBJ.jobs[job_index].splice_count, 0, obj);
       // }
     } catch (e) {
-      console.error("bug");
+      console.error('bug');
       // _session.WORKER_OBJ.jobs.splice(0, 0, obj);
     }
   } else {
@@ -9730,7 +9650,7 @@ func.events.execute = async function (
   containerP,
   elementP,
   rowP,
-  NA_colP,
+  evt,
   descP,
   rootScreenIdP,
   dsSessionP,
@@ -9748,14 +9668,14 @@ func.events.execute = async function (
   NA_viewIdP,
   NA_nodeIdP,
   NA_parentDataSourceNoP,
-  $div
+  $div,
 ) {
   var _session = SESSION_OBJ[SESSION_ID];
   var _ds = _session.DS_GLB[dsSessionP];
-  if (functionP === "update") refIdP = null; // in case of left over when program changing from call function to update
+  if (functionP === 'update') refIdP = null; // in case of left over when program changing from call function to update
 
   var job_index = func.events.find_job_index(SESSION_ID, jobNoP);
-  if (_session.WORKER_OBJ.jobs?.[job_index]?.stat === "busy") {
+  if (_session.WORKER_OBJ.jobs?.[job_index]?.stat === 'busy') {
     if (jobNoP) _session.WORKER_OBJ.stat = job_index;
     return;
   }
@@ -9772,61 +9692,44 @@ func.events.execute = async function (
   }
 
   if (_session.WORKER_OBJ.jobs[job_index]) {
-    _session.WORKER_OBJ.jobs[job_index].stat = "busy";
+    _session.WORKER_OBJ.jobs[job_index].stat = 'busy';
   }
 
   var dsSession = dsSessionP; // new 2020420
   var field_elm = elementP;
 
   var calling_field_id = field_elm;
-  if (field_elm && typeof field_elm === "object")
-    calling_field_id = field_elm.attr("xu-ui-id");
+  if (field_elm && typeof field_elm === 'object') calling_field_id = field_elm.attr('xu-ui-id');
 
   var log_nodeId;
   var log_prog_id;
   var log_source;
 
-  if (_session.DS_GLB[dsSession]?.prog_id)
-    log_prog_id = _session.DS_GLB[dsSession].prog_id;
-  log_nodeId = log_prog_id + "_" + eventIdP;
+  if (_session.DS_GLB[dsSession]?.prog_id) log_prog_id = _session.DS_GLB[dsSession].prog_id;
+  log_nodeId = log_prog_id + '_' + eventIdP;
   var log_prop = callingSourceP;
-  if (callingSourceP === "system event") {
-    log_prop = "global event";
+  if (callingSourceP === 'system event') {
+    log_prop = 'global event';
   }
   if (calling_field_id) {
     const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
-    let _field_obj = func.common.find_item_by_key(
-      _view_obj.progFields,
-      "field_id",
-      calling_field_id
-    );
-    log_nodeId = log_prog_id + "_" + eventIdP + "_" + _field_obj?.id;
+    let _field_obj = func.common.find_item_by_key(_view_obj.progFields, 'field_id', calling_field_id);
+    log_nodeId = log_prog_id + '_' + eventIdP + '_' + _field_obj?.id;
 
     log_source = calling_field_id;
   }
   if (elementP) {
     log_prop = triggerP;
-    log_nodeId = log_nodeId + "_ui_prop"; //+"_"+eventIdP;
+    log_nodeId = log_nodeId + '_ui_prop'; //+"_"+eventIdP;
   }
   //check condition
   var expCond;
   if (event_propertiesP) {
     // conditional event
     if (event_propertiesP?.props?.condition) {
-      expCond = await func.expression.get(
-        SESSION_ID,
-        event_propertiesP.props.condition,
-        dsSession,
-        "condition",
-        null,
-        null,
-        null,
-        calling_field_id ? calling_field_id : calling_triggerP,
-        null,
-        descP
-      ); // execute expression
+      expCond = await func.expression.get(SESSION_ID, event_propertiesP.props.condition, dsSession, 'condition', null, null, null, calling_field_id ? calling_field_id : calling_triggerP, null, descP); // execute expression
       func.utils.debug.log(SESSION_ID, log_nodeId, {
-        module: "event",
+        module: 'event',
         action: log_prop,
         source: log_source,
         prop: descP,
@@ -9834,7 +9737,7 @@ func.events.execute = async function (
         result: expCond.result,
         error: expCond.error,
         fields: expCond.fields,
-        type: "event",
+        type: 'event',
         prog_id: log_prog_id,
         conditional: true,
       });
@@ -9843,21 +9746,13 @@ func.events.execute = async function (
         // condition failed // === true 03/04/16
         func.events.delete_job(SESSION_ID, jobNoP);
 
-        func.utils.debug.watch(
-          SESSION_ID,
-          calling_trigger_prop?.id,
-          functionP,
-          "",
-          "",
-          expCond,
-          true
-        );
+        func.utils.debug.watch(SESSION_ID, calling_trigger_prop?.id, functionP, '', '', expCond, true);
         return;
       }
     } // Non conditional event
     else {
       func.utils.debug.log(SESSION_ID, log_nodeId, {
-        module: "event",
+        module: 'event',
         action: log_prop,
         source: log_source,
         prop: descP,
@@ -9865,7 +9760,7 @@ func.events.execute = async function (
         result: null,
         error: null,
         fields: null,
-        type: "event",
+        type: 'event',
         prog_id: log_prog_id,
       });
     }
@@ -9888,47 +9783,27 @@ func.events.execute = async function (
   // };
 
   const get_params_obj = async function () {
-    const _prog = await func.utils.VIEWS_OBJ.get(
-      SESSION_ID,
-      await get_prog_id()
-    );
+    const _prog = await func.utils.VIEWS_OBJ.get(SESSION_ID, await get_prog_id());
     if (!_prog) {
       func.events.delete_job(SESSION_ID, jobNoP);
-      return func.utils.debug_report(
-        SESSION_ID,
-        "func.events.execute",
-        "Program not found: " + refIdP.prog,
-        "E"
-      );
+      return func.utils.debug_report(SESSION_ID, 'func.events.execute', 'Program not found: ' + refIdP.prog, 'E');
     }
 
     // get in parameters
     var params_obj = {};
     if (_prog?.properties?.progParams) {
-      for await (const [key, val] of Object.entries(
-        _prog.properties.progParams
-      )) {
-        if (!val.data.dir === "in") continue;
-        if (
-          typeof args.parameters_obj_inP?.[val.data.parameter] !== "undefined"
-        ) {
+      for await (const [key, val] of Object.entries(_prog.properties.progParams)) {
+        if (!val.data.dir === 'in') continue;
+        if (typeof args.parameters_obj_inP?.[val.data.parameter] !== 'undefined') {
           if (args.parameters_obj_inP?.[val.data.parameter].fx) {
-            let ret = await func.expression.get(
-              SESSION_ID,
-              args.parameters_obj_inP?.[val.data.parameter].fx,
-              dsSession,
-              "parameters"
-            );
+            let ret = await func.expression.get(SESSION_ID, args.parameters_obj_inP?.[val.data.parameter].fx, dsSession, 'parameters');
             params_obj[val.data.parameter] = ret.result;
           } else {
-            params_obj[val.data.parameter] =
-              args.parameters_obj_inP?.[val.data.parameter].value;
+            params_obj[val.data.parameter] = args.parameters_obj_inP?.[val.data.parameter].value;
           }
           continue;
         }
-        console.warn(
-          `Warning: Program ${_prog.properties.menuName} expected In parameter: ${val.data.parameter} but received null instead`
-        );
+        console.warn(`Warning: Program ${_prog.properties.menuName} expected In parameter: ${val.data.parameter} but received null instead`);
       }
     }
     return params_obj;
@@ -9937,15 +9812,8 @@ func.events.execute = async function (
   const get_prog_id = async function () {
     let _prop = args?.calling_trigger_prop?.data?.name?.properties;
     let _prog_id = args.prog_id;
-    if (_prop?.["xu-exp:prog"]) {
-      _prog_id = (
-        await func.expression.get(
-          SESSION_ID,
-          _prop["xu-exp:prog"],
-          dsSession,
-          "prog_id expression"
-        )
-      ).result;
+    if (_prop?.['xu-exp:prog']) {
+      _prog_id = (await func.expression.get(SESSION_ID, _prop['xu-exp:prog'], dsSession, 'prog_id expression')).result;
     }
 
     return _prog_id;
@@ -9967,7 +9835,6 @@ func.events.execute = async function (
   //   return _value;
   // };
 
-
   var args = {
     prog_id: refIdP?.prog,
     screenIdP: refIdP?.prog,
@@ -9995,40 +9862,20 @@ func.events.execute = async function (
       var $calling_container;
       if (_session.WORKER_OBJ.jobs[job_index]) {
         if (_session.WORKER_OBJ.jobs[job_index].paramsP) {
-          $calling_container = $(
-            "#" + _session.WORKER_OBJ.jobs[job_index].paramsP.callingContainerP
-          );
+          $calling_container = $('#' + _session.WORKER_OBJ.jobs[job_index].paramsP.callingContainerP);
         } else {
-          $calling_container = ""; // calling from datasource 0
+          $calling_container = ''; // calling from datasource 0
           _session.WORKER_OBJ.jobs[job_index].paramsP = {};
         }
       }
 
       if (!refIdP.prog) {
         func.events.delete_job(SESSION_ID, jobNoP);
-        return func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          "Program is empty",
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'func.events.execute', 'Program is empty', 'E');
       }
 
       const params_obj = await get_params_obj();
-      return await func.UI.screen.init(
-        SESSION_ID,
-        await get_prog_id(),
-        $(containerP)?.data()?.xuData.screenId,
-        _session.DS_GLB[dsSession],
-        $calling_container,
-        eventIdP,
-        rowP,
-        jobNoP,
-        is_panel,
-        params_obj,
-        functionP,
-        args.call_screen_propertiesP
-      );
+      return await func.UI.screen.init(SESSION_ID, await get_prog_id(), $(containerP)?.data()?.xuData.screenId, _session.DS_GLB[dsSession], $calling_container, eventIdP, rowP, jobNoP, is_panel, params_obj, functionP, args.call_screen_propertiesP);
     },
     call_modal: async function () {
       return await fx.Call_window();
@@ -10051,101 +9898,66 @@ func.events.execute = async function (
 
       const set_SYS_GLOBAL_OBJ_WIDGET_INFO = async function (docP) {
         var obj = _.clone(docP);
-        obj.date = await func.utils.get_dateTime(
-          SESSION_ID,
-          "SYS_DATE",
-          docP.date
-        );
-        obj.time = await func.utils.get_dateTime(
-          SESSION_ID,
-          "SYS_TIME",
-          docP.date
-        );
+        obj.date = await func.utils.get_dateTime(SESSION_ID, 'SYS_DATE', docP.date);
+        obj.time = await func.utils.get_dateTime(SESSION_ID, 'SYS_TIME', docP.date);
 
         var datasource_changes = {
           [0]: {
-            ["data_system"]: {
-              ["SYS_GLOBAL_OBJ_WIDGET_INFO"]: obj,
+            ['data_system']: {
+              ['SYS_GLOBAL_OBJ_WIDGET_INFO']: obj,
             },
           },
         };
         await func.datasource.update(SESSION_ID, datasource_changes);
       };
       const call_plugin_api = async function (plugin_nameP, dataP) {
-        return await func.utils.call_plugin_api(
-          SESSION_ID,
-          plugin_nameP,
-          dataP
-        );
+        return await func.utils.call_plugin_api(SESSION_ID, plugin_nameP, dataP);
       };
       const report_error = function (descP, warn) {
-        func.utils.debug.log(
-          SESSION_ID,
-          _session.DS_GLB[dsP].prog_id +
-          "_" +
-          _session.DS_GLB[dsP].callingMenuId,
-          {
-            module: "widgets",
-            action: "Init",
+        func.utils.debug.log(SESSION_ID, _session.DS_GLB[dsP].prog_id + '_' + _session.DS_GLB[dsP].callingMenuId, {
+          module: 'widgets',
+          action: 'Init',
+          source: sourceP,
+          prop: descP,
+          details: descP,
+          result: null,
+          error: warn ? false : true,
+          fields: null,
+          type: 'widgets',
+          prog_id: _session.DS_GLB[dsP].prog_id,
+        });
+      };
+      const get_fields_data = async function (fields, props) {
+        const report_error = function (descP, warn) {
+          func.utils.debug.log(SESSION_ID, _session.DS_GLB[dsP].prog_id + '_' + _session.DS_GLB[dsP].callingMenuId, {
+            module: 'widgets',
+            action: 'Init',
             source: sourceP,
             prop: descP,
             details: descP,
             result: null,
             error: warn ? false : true,
             fields: null,
-            type: "widgets",
+            type: 'widgets',
             prog_id: _session.DS_GLB[dsP].prog_id,
-          }
-        );
-      };
-      const get_fields_data = async function (fields, props) {
-        const report_error = function (descP, warn) {
-          func.utils.debug.log(
-            SESSION_ID,
-            _session.DS_GLB[dsP].prog_id +
-            "_" +
-            _session.DS_GLB[dsP].callingMenuId,
-            {
-              module: "widgets",
-              action: "Init",
-              source: sourceP,
-              prop: descP,
-              details: descP,
-              result: null,
-              error: warn ? false : true,
-              fields: null,
-              type: "widgets",
-              prog_id: _session.DS_GLB[dsP].prog_id,
-            }
-          );
+          });
         };
         const get_property_value = async function (fieldIdP, val) {
           // var value = props[fieldIdP];
 
-          var value =
-            props[fieldIdP] ||
-            (typeof val.defaultValue === "function"
-              ? val?.defaultValue?.()
-              : val?.defaultValue);
+          var value = props[fieldIdP] || (typeof val.defaultValue === 'function' ? val?.defaultValue?.() : val?.defaultValue);
 
           if (props[`xu-exp:${fieldIdP}`]) {
-            value = (
-              await func.expression.get(
-                SESSION_ID,
-                props[`xu-exp:${fieldIdP}`],
-                dsP,
-                "widget property"
-              )
-            ).result;
+            value = (await func.expression.get(SESSION_ID, props[`xu-exp:${fieldIdP}`], dsP, 'widget property')).result;
           }
 
           return func.common.get_cast_val(
             SESSION_ID,
-            "widgets",
+            'widgets',
             fieldIdP,
             val.type, //val.type !== "string" || val.type !== "number" ? "string" : val.type,
             value,
-            null
+            null,
           );
         };
         var data_obj = {};
@@ -10168,51 +9980,36 @@ func.events.execute = async function (
       };
 
       try {
-        const _plugin =
-          APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name];
+        const _plugin = APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name];
 
-        const index = await func.utils.get_plugin_resource(
-          SESSION_ID,
-          plugin_name,
-          `${_plugin.manifest["index.mjs"].dist ? "dist/" : ""}index.mjs`
-        );
+        const index = await func.utils.get_plugin_resource(SESSION_ID, plugin_name, `${_plugin.manifest['index.mjs'].dist ? 'dist/' : ''}index.mjs`);
 
         const methods = index.methods;
         if (methods && !methods[method]) {
-          return report_error("method not found");
+          return report_error('method not found');
         }
 
-        const fields_ret = await get_fields_data(
-          methods[method].fields,
-          propsP
-        );
+        const fields_ret = await get_fields_data(methods[method].fields, propsP);
 
         if (fields_ret.code < 0) {
           return report_error(fields_ret.data);
         }
         const fields = fields_ret.data;
 
-        const plugin_setup_ret = await func.utils.get_plugin_setup(
-          SESSION_ID,
-          plugin_name
-        );
+        const plugin_setup_ret = await func.utils.get_plugin_setup(SESSION_ID, plugin_name);
         if (plugin_setup_ret.code < 0) {
           return report_error(plugin_setup_ret);
         }
 
-        const api_utils = await func.common.get_module(
+        const api_utils = await func.common.get_module(SESSION_ID, 'xuda-api-library.mjs', {
+          func,
+          glb,
+          SESSION_OBJ,
           SESSION_ID,
-          "xuda-api-library.mjs",
-          {
-            func,
-            glb,
-            SESSION_OBJ,
-            SESSION_ID,
-            APP_OBJ,
-            dsSession: dsP,
-            job_id: jobNoP,
-          }
-        );
+          APP_OBJ,
+          dsSession: dsP,
+          job_id: jobNoP,
+        });
 
         const params = {
           SESSION_ID,
@@ -10231,11 +10028,7 @@ func.events.execute = async function (
           api_utils,
         };
 
-        const fx = await func.utils.get_plugin_resource(
-          SESSION_ID,
-          plugin_name,
-          `${_plugin.manifest["runtime.mjs"].dist ? "dist/" : ""}runtime.mjs`
-        );
+        const fx = await func.utils.get_plugin_resource(SESSION_ID, plugin_name, `${_plugin.manifest['runtime.mjs'].dist ? 'dist/' : ''}runtime.mjs`);
 
         if (!fx[method]) {
           throw `Method: ${method} does not exist`;
@@ -10249,41 +10042,21 @@ func.events.execute = async function (
     },
 
     call_native_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
-      const result = await module.call_javascript(
-        SESSION_ID,
-        jobNoP,
-        refIdP,
-        dsSession
-      );
+      const module = await func.common.get_module(SESSION_ID, 'xuda-event-javascript-module.mjs');
+      const result = await module.call_javascript(SESSION_ID, jobNoP, refIdP, dsSession);
       await func.datasource.set_outputField(SESSION_ID, dsSessionP, result, args);
 
-      return result
+      return result;
     },
     call_evaluate_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
-      const result = await module.call_javascript(
-        SESSION_ID,
-        jobNoP,
-        refIdP,
-        dsSession,
-        true
-      );
+      const module = await func.common.get_module(SESSION_ID, 'xuda-event-javascript-module.mjs');
+      const result = await module.call_javascript(SESSION_ID, jobNoP, refIdP, dsSession, true);
       await func.datasource.set_outputField(SESSION_ID, dsSessionP, result, args);
 
-      return result
+      return result;
     },
     execute_native_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
+      const module = await func.common.get_module(SESSION_ID, 'xuda-event-javascript-module.mjs');
 
       const result = await module.run_javascript(
         SESSION_ID,
@@ -10291,17 +10064,14 @@ func.events.execute = async function (
         dsSession,
         `(async function(el) {
           ${refIdP.value}
-          })(document.querySelector(\`[xu-ui-id=${elementP}]\`))`
+          })(document.querySelector(\`[xu-ui-id=${elementP}]\`))`,
       );
       await func.datasource.set_outputField(SESSION_ID, dsSessionP, result, args);
 
-      return result
+      return result;
     },
     execute_evaluate_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
+      const module = await func.common.get_module(SESSION_ID, 'xuda-event-javascript-module.mjs');
 
       const result = await module.run_javascript(
         SESSION_ID,
@@ -10310,11 +10080,11 @@ func.events.execute = async function (
         `(async function(el) {
           ${refIdP.value}
           })(document.querySelector(\`[xu-ui-id=${elementP}]\`))`,
-        true
+        true,
       );
       await func.datasource.set_outputField(SESSION_ID, dsSessionP, result, args);
 
-      return result
+      return result;
     },
     loader_on: async function () {
       glb.CURRENT_APP_LOADING = null;
@@ -10335,131 +10105,59 @@ func.events.execute = async function (
         //  if (descP.value) {
         $(document).trigger(refIdP.value, [_session.DS_GLB[dsSession]]);
       } else {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          "Event name missing",
-          "E"
-        );
+        func.utils.debug_report(SESSION_ID, 'func.events.execute', 'Event name missing', 'E');
       }
       func.events.delete_job(SESSION_ID, jobNoP);
       // if (callbackP) callbackP();
     },
 
     invoke_action: async function () {
-      func.utils.debug.watch(
-        SESSION_ID,
-        calling_trigger_prop?.id,
-        functionP,
-        null,
-        null,
-        expCond
-      );
+      func.utils.debug.watch(SESSION_ID, calling_trigger_prop?.id, functionP, null, null, expCond);
 
-      await func.action.execute(
-        SESSION_ID,
-        refIdP.value,
-        _ds,
-        null,
-        null,
-        jobNoP,
-        containerP
-      );
+      await func.action.execute(SESSION_ID, refIdP.value, _ds, null, null, jobNoP, containerP);
     },
     raise_event: async function () {
       var _ds = _session.DS_GLB[dsSession];
       const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
-      if (callingSourceP === "grid" || callingSourceP === "form") {
-        let _field_obj = func.common.find_item_by_key(
-          _view_obj.progFields,
-          "field_id",
-          field_elm
-        );
+      if (callingSourceP === 'grid' || callingSourceP === 'form') {
+        let _field_obj = func.common.find_item_by_key(_view_obj.progFields, 'field_id', field_elm);
         var event_name = _field_obj?.triggers?.[eventIdP].name.event;
 
-        if (_field_obj?.triggers?.[eventIdP].name?.properties["xu-exp:event"]) {
-          event_name = (
-            await func.expression.get(
-              SESSION_ID,
-              props[`xu-exp:event`],
-              dsSession,
-              "event_name expression"
-            )
-          ).result;
+        if (_field_obj?.triggers?.[eventIdP].name?.properties['xu-exp:event']) {
+          event_name = (await func.expression.get(SESSION_ID, props[`xu-exp:event`], dsSession, 'event_name expression')).result;
         }
 
         if (field_elm && event_name) {
           // get container for fields events
-          const dsP = await func.datasource.find_event_dataSource(
-            SESSION_ID,
-            event_name,
-            dsSession
-          );
+          const dsP = await func.datasource.find_event_dataSource(SESSION_ID, event_name, dsSession);
 
-          return await func.datasource.run_events_functions(
-            SESSION_ID,
-            dsP,
-            event_name,
-            jobNoP,
-            null,
-            calling_trigger_prop?.data?.name?.parameters || {}
-          );
+          return await func.datasource.run_events_functions(SESSION_ID, dsP, event_name, jobNoP, null, calling_trigger_prop?.data?.name?.parameters || {});
         }
         // done_execution(event_name);
       }
-      if (callingSourceP.includes("event")) {
+      if (callingSourceP.includes('event')) {
         let event_name = refIdP.event;
 
-        if (refIdP?.properties?.["xu-exp:event"]) {
-          event_name = (
-            await func.expression.get(
-              SESSION_ID,
-              refIdP.properties["xu-exp:event"],
-              dsSession,
-              "event_name expression"
-            )
-          ).result;
+        if (refIdP?.properties?.['xu-exp:event']) {
+          event_name = (await func.expression.get(SESSION_ID, refIdP.properties['xu-exp:event'], dsSession, 'event_name expression')).result;
         }
 
-        const dsP = await func.datasource.find_event_dataSource(
-          SESSION_ID,
-          event_name,
-          dsSession
-        );
+        const dsP = await func.datasource.find_event_dataSource(SESSION_ID, event_name, dsSession);
 
-        await func.datasource.run_events_functions(
-          SESSION_ID,
-          dsP,
-          event_name,
-          jobNoP,
-          calling_trigger_prop?.props?.async,
-          calling_trigger_prop?.data?.name?.parameters || {}
-        );
+        await func.datasource.run_events_functions(SESSION_ID, dsP, event_name, jobNoP, calling_trigger_prop?.props?.async, calling_trigger_prop?.data?.name?.parameters || {});
         // done_execution(event_name);
       }
 
       func.events.delete_job(SESSION_ID, jobNoP);
       // if (callbackP) callbackP();
 
-      func.utils.debug.watch(
-        SESSION_ID,
-        calling_trigger_prop?.id,
-        functionP,
-        "",
-        "",
-        expCond
-      );
+      func.utils.debug.watch(SESSION_ID, calling_trigger_prop?.id, functionP, '', '', expCond);
     },
     get_data: async function () {
       const params_obj = await get_params_obj();
 
       if (!(await get_prog_id())) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} > ${triggerP} > ${functionP} > program ${prog} is missing`,
-          "E"
-        );
+        func.utils.debug_report(SESSION_ID, 'func.events.execute', `${elementP} > ${triggerP} > ${functionP} > program ${prog} is missing`, 'E');
         func.events.delete_job(SESSION_ID, jobNoP);
         return;
       }
@@ -10472,41 +10170,14 @@ func.events.execute = async function (
 
       // args.prog_id = _viewId;
       if (_ds) {
-        func.utils.debug.watch(
-          SESSION_ID,
-          calling_trigger_prop?.id,
-          functionP,
-          null,
-          calling_trigger_prop,
-          expCond
-        );
+        func.utils.debug.watch(SESSION_ID, calling_trigger_prop?.id, functionP, null, calling_trigger_prop, expCond);
         // }
-        const ret = await func.datasource.create(
-          SESSION_ID,
-          await get_prog_id(),
-          args.dataSourceNoP,
-          args.parentDataSourceNoP,
-          args.containerIdP,
-          args.rowIdP,
-          args.jobNoP,
-          args.calling_trigger_prop,
-          null,
-          null,
-          args.callingSourceP,
-          args.calling_jobP,
-          args.screen_dsP,
-          args.is_panelP,
-          params_obj
-        );
+        const ret = await func.datasource.create(SESSION_ID, await get_prog_id(), args.dataSourceNoP, args.parentDataSourceNoP, args.containerIdP, args.rowIdP, args.jobNoP, args.calling_trigger_prop, null, null, args.callingSourceP, args.calling_jobP, args.screen_dsP, args.is_panelP, params_obj);
 
         let _ds_new = _session.DS_GLB[ret.dsSessionP];
         let parameters = args?.calling_trigger_prop?.data?.name?.parameters;
         if (parameters && !_.isEmpty(parameters)) {
-          await func.datasource.update_changes_for_out_parameter(
-            SESSION_ID,
-            _ds_new.dsSession,
-            _ds.dsSession
-          );
+          await func.datasource.update_changes_for_out_parameter(SESSION_ID, _ds_new.dsSession, _ds.dsSession);
         }
         // if (parameters && !_.isEmpty(parameters) && _ds_new.PARAM_OUT_INFO) {
         //   let data = {};
@@ -10535,7 +10206,7 @@ func.events.execute = async function (
         // }
 
         func.events.delete_job(SESSION_ID, jobNoP);
-        return _ds_new
+        return _ds_new;
       }
     },
     set_data: async function () {
@@ -10545,24 +10216,12 @@ func.events.execute = async function (
       const result = await this.get_data();
 
       // await set_outputField(SESSION_ID, elementP, triggerP, functionP, dsSessionP, result);
-      return result
-
+      return result;
     },
     update: async function () {
-      const obj_values_to_update =
-        func.datasource.get_viewFields_for_update_function(
-          SESSION_ID,
-          calling_trigger_prop,
-          null,
-          dsSessionP
-        );
+      const obj_values_to_update = func.datasource.get_viewFields_for_update_function(SESSION_ID, calling_trigger_prop, null, dsSessionP);
       if (!obj_values_to_update || _.isEmpty(obj_values_to_update)) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "Update values object is empty",
-          "",
-          "W"
-        );
+        func.utils.debug_report(SESSION_ID, 'Update values object is empty', '', 'W');
         if (jobNoP) func.events.delete_job(SESSION_ID, jobNoP);
         return;
       }
@@ -10575,32 +10234,8 @@ func.events.execute = async function (
           $element = $(`[xu-ui-id="${elementP}"]`).clone(true);
         }
 
-        let ret_field_id = await func.expression.get(
-          SESSION_ID,
-          val.id.trim(),
-          dsSessionP,
-          "update",
-          null,
-          null,
-          null,
-          null,
-          null,
-          null,
-          $element?.length ? $element?.data()?.xuData?.iterate_info : null
-        );
-        let ret_value = await func.expression.get(
-          SESSION_ID,
-          val.val.trim(),
-          dsSessionP,
-          "update",
-          null,
-          null,
-          null,
-          null,
-          null,
-          null,
-          $element?.length ? $element?.data()?.xuData?.iterate_info : null
-        );
+        let ret_field_id = await func.expression.get(SESSION_ID, val.id.trim(), dsSessionP, 'update', null, null, null, null, null, null, $element?.length ? $element?.data()?.xuData?.iterate_info : null);
+        let ret_value = await func.expression.get(SESSION_ID, val.val.trim(), dsSessionP, 'update', null, null, null, null, null, null, $element?.length ? $element?.data()?.xuData?.iterate_info : null);
         let _field_id = ret_field_id.result;
         let _value = ret_value.result;
 
@@ -10609,25 +10244,16 @@ func.events.execute = async function (
 
       let datasource_changes = {};
       for await (const change of updates) {
-        let ret_get_value = await func.datasource.get_value(
-          SESSION_ID,
-          change._field_id,
-          dsSessionP
-        );
+        let ret_get_value = await func.datasource.get_value(SESSION_ID, change._field_id, dsSessionP);
         if (ret_get_value.found) {
           let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
           if (!datasource_changes[_ds.dsSession]) {
             datasource_changes[_ds.dsSession] = {};
           }
-          if (
-            !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
-          ) {
-            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
-              {};
+          if (!datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]) {
+            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] = {};
           }
-          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
-            change._field_id
-          ] = change._value;
+          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][change._field_id] = change._value;
         }
       }
 
@@ -10636,23 +10262,11 @@ func.events.execute = async function (
       // return changes;
     },
     call_alert: async function () {
-      await func.utils.alerts.invoke(
-        SESSION_ID,
-        "call_alert",
-        refIdP,
-        log_source,
-        dsSession
-      );
+      await func.utils.alerts.invoke(SESSION_ID, 'call_alert', refIdP, log_source, dsSession);
       func.events.delete_job(SESSION_ID, jobNoP);
     },
     alert: async function () {
-      await func.utils.alerts.invoke(
-        SESSION_ID,
-        "alert",
-        refIdP,
-        log_source,
-        dsSession
-      );
+      await func.utils.alerts.invoke(SESSION_ID, 'alert', refIdP, log_source, dsSession);
       func.events.delete_job(SESSION_ID, jobNoP);
     },
     delay: async function () {
@@ -10671,18 +10285,11 @@ func.events.execute = async function (
       const _prog_id = await get_prog_id();
 
       if (!_prog_id) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} > ${triggerP} > ${functionP} > program not defined`,
-          "E"
-        );
+        func.utils.debug_report(SESSION_ID, 'func.events.execute', `${elementP} > ${triggerP} > ${functionP} > program not defined`, 'E');
         func.events.delete_job(SESSION_ID, jobNoP);
         return;
       }
 
-
-
       // if (!output_field) {
       //   func.utils.debug_report(
       //     SESSION_ID,
@@ -10698,37 +10305,24 @@ func.events.execute = async function (
 
       await func.datasource.set_outputField(SESSION_ID, dsSessionP, api_ret, args);
 
-
       func.events.delete_job(SESSION_ID, jobNoP);
     },
     call_system_api: async function () {
-      const api_method = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "api_method");
+      const api_method = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, 'api_method');
 
       if (!api_method) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} >${triggerP} >${functionP} > api_method not defined`,
-          "E"
-        );
+        func.utils.debug_report(SESSION_ID, 'func.events.execute', `${elementP} >${triggerP} >${functionP} > api_method not defined`, 'E');
         func.events.delete_job(SESSION_ID, jobNoP);
         return;
       }
       let payload = {};
-      const _payload = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "payload");
+      const _payload = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, 'payload');
       if (_payload) {
         const get_payload_property_value = async function (prop_name) {
           let _prop = _payload;
           let _value = _prop[prop_name];
           if (_prop?.[`xu-exp:${prop_name}`]) {
-            _value = (
-              await func.expression.get(
-                SESSION_ID,
-                _prop[`xu-exp:${prop_name}`],
-                dsSession,
-                `${prop_name} expression`
-              )
-            ).result;
+            _value = (await func.expression.get(SESSION_ID, _prop[`xu-exp:${prop_name}`], dsSession, `${prop_name} expression`)).result;
           }
 
           return _value;
@@ -10736,7 +10330,7 @@ func.events.execute = async function (
 
         for await (let [key, val] of Object.entries(_payload)) {
           // if (key.substring(0, 7) !== "xu-exp:") {
-          const new_key = key.replaceAll("xu-exp:", ""); //key.substring(0, 7) === "xu-exp:" ? key.substring(7): key
+          const new_key = key.replaceAll('xu-exp:', ''); //key.substring(0, 7) === "xu-exp:" ? key.substring(7): key
           payload[new_key] = await get_payload_property_value(new_key);
           // }
         }
@@ -10753,7 +10347,7 @@ func.events.execute = async function (
       //   return;
       // }
 
-      const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "outputField");
+      const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, 'outputField');
 
       // if (!output_field) {
       //   func.utils.debug_report(
@@ -10770,89 +10364,57 @@ func.events.execute = async function (
       if (output_field) {
         let datasource_changes = {};
 
-        let ret_get_value = await func.datasource.get_value(
-          SESSION_ID,
-          output_field,
-          dsSessionP
-        );
+        let ret_get_value = await func.datasource.get_value(SESSION_ID, output_field, dsSessionP);
         if (ret_get_value.found) {
           let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
           if (!datasource_changes[_ds.dsSession]) {
             datasource_changes[_ds.dsSession] = {};
           }
-          if (
-            !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
-          ) {
-            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
-              {};
+          if (!datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]) {
+            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] = {};
           }
-          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
-            output_field
-          ] = api_ret;
+          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][output_field] = api_ret;
           await func.datasource.update(SESSION_ID, datasource_changes);
         }
       }
       func.events.delete_job(SESSION_ID, jobNoP);
     },
     call_external_api: async function () {
-      const method = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "method");
+      const method = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, 'method');
 
       if (!method) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} >${triggerP} >${functionP} > method not defined`,
-          "E"
-        );
+        func.utils.debug_report(SESSION_ID, 'func.events.execute', `${elementP} >${triggerP} >${functionP} > method not defined`, 'E');
         func.events.delete_job(SESSION_ID, jobNoP);
         return;
       }
 
-      const url = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "url");
+      const url = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, 'url');
 
       if (!url) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} >${triggerP} >${functionP} > url not defined`,
-          "E"
-        );
+        func.utils.debug_report(SESSION_ID, 'func.events.execute', `${elementP} >${triggerP} >${functionP} > url not defined`, 'E');
         func.events.delete_job(SESSION_ID, jobNoP);
         return;
       }
 
-      const payload_arr = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "payload");
+      const payload_arr = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, 'payload');
 
       const report_conversion_error = function (res, typeP, valP) {
         var msg = `${elementP} >${triggerP} >${functionP} > error converting from ${valP} to ${typeP}`;
         if (error) {
-          return func.utils.debug_report(SESSION_ID, msg, "", "W");
+          return func.utils.debug_report(SESSION_ID, msg, '', 'W');
         }
-        func.utils.debug_report(
-          SESSION_ID,
-          msg + " " + _.capitalize(source) + prog_info,
-          "",
-          "E"
-        );
+        func.utils.debug_report(SESSION_ID, msg + ' ' + _.capitalize(source) + prog_info, '', 'E');
       };
       const report_conversion_warn = function (res) {
         var msg = `${elementP} >${triggerP} >${functionP} > type mismatch auto conversion from value ${valP} to ${typeP}`;
-        func.utils.debug_report(
-          SESSION_ID,
-          msg + " " + _.capitalize(source) + prog_info,
-          "",
-          "W"
-        );
+        func.utils.debug_report(SESSION_ID, msg + ' ' + _.capitalize(source) + prog_info, '', 'W');
       };
       // var ret = valP;
       if (error) {
         return report_conversion_error();
       }
 
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-get-cast-util-module.mjs"
-      );
+      const module = await func.common.get_module(SESSION_ID, 'xuda-get-cast-util-module.mjs');
       // return module.cast(
       //   typeP,
       //   valP,
@@ -10863,16 +10425,11 @@ func.events.execute = async function (
       var payload = _.reduce(
         payload_arr,
         (ret, val, key) => {
-          ret[val.key] = module.cast(
-            val.type,
-            val.val,
-            report_conversion_error,
-            report_conversion_warn
-          );
+          ret[val.key] = module.cast(val.type, val.val, report_conversion_error, report_conversion_warn);
 
           return ret;
         },
-        {}
+        {},
       );
       // if (!payload) {
       //   func.utils.debug_report(
@@ -10885,7 +10442,7 @@ func.events.execute = async function (
       //   return;
       // }
 
-      const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "outputField");
+      const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, 'outputField');
 
       // if (!output_field) {
       //   func.utils.debug_report(
@@ -10902,25 +10459,16 @@ func.events.execute = async function (
       if (output_field) {
         let datasource_changes = {};
 
-        let ret_get_value = await func.datasource.get_value(
-          SESSION_ID,
-          output_field,
-          dsSessionP
-        );
+        let ret_get_value = await func.datasource.get_value(SESSION_ID, output_field, dsSessionP);
         if (ret_get_value.found) {
           let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
           if (!datasource_changes[_ds.dsSession]) {
             datasource_changes[_ds.dsSession] = {};
           }
-          if (
-            !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
-          ) {
-            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
-              {};
+          if (!datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]) {
+            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] = {};
           }
-          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
-            output_field
-          ] = api_ret;
+          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][output_field] = api_ret;
           await func.datasource.update(SESSION_ID, datasource_changes);
         }
       }
@@ -10953,16 +10501,9 @@ func.events.delete_job = function (SESSION_ID, jobNoP) {
   var dsSession = _session.WORKER_OBJ.jobs[job_index].dsSessionP;
   let ds_obj = _session?.DS_GLB[dsSession];
   if (ds_obj) {
-    delete SCREEN_BLOCKER_OBJ[
-      ds_obj.screenId +
-      (ds_obj.callingScreenId ? "_" + ds_obj.callingScreenId : "")
-    ];
+    delete SCREEN_BLOCKER_OBJ[ds_obj.screenId + (ds_obj.callingScreenId ? '_' + ds_obj.callingScreenId : '')];
   }
-  if (
-    dsSession &&
-    ds_obj?.loops_limit &&
-    ds_obj?.loops_count < ds_obj?.loops_limit - 1
-  ) {
+  if (dsSession && ds_obj?.loops_limit && ds_obj?.loops_count < ds_obj?.loops_limit - 1) {
     return;
   }
   _session.WORKER_OBJ.stat = null;
@@ -10980,17 +10521,9 @@ func.events.delete_job_0 = function (SESSION_ID) {
   var dsSession = _session.WORKER_OBJ.jobs[job_index].dsSession;
   let ds_obj = _session?.DS_GLB[dsSession];
   if (ds_obj) {
-    delete SCREEN_BLOCKER_OBJ[
-      ds_obj.screenId +
-      (ds_obj.callingScreenId ? "_" + ds_obj.callingScreenId : "")
-    ];
+    delete SCREEN_BLOCKER_OBJ[ds_obj.screenId + (ds_obj.callingScreenId ? '_' + ds_obj.callingScreenId : '')];
   }
-  if (
-    dsSession &&
-    ds_obj &&
-    ds_obj.loops_limit &&
-    ds_obj.loops_count < ds_obj.loops_limit - 1
-  ) {
+  if (dsSession && ds_obj && ds_obj.loops_limit && ds_obj.loops_count < ds_obj.loops_limit - 1) {
     return;
   }
   _session.WORKER_OBJ.stat = null;
@@ -11032,8 +10565,7 @@ setInterval(function () {
 }, 1000);
 
 func.events.set_browser_changes = function (dsP, fieldsChangedP) {
-  if (fieldsChangedP.includes("SYS_GLOBAL_STR_BROWSER_TITLE"))
-    document.title = dsP.dataset_new["SYS_GLOBAL_STR_BROWSER_TITLE"];
+  if (fieldsChangedP.includes('SYS_GLOBAL_STR_BROWSER_TITLE')) document.title = dsP.dataset_new['SYS_GLOBAL_STR_BROWSER_TITLE'];
 };
 
 func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
@@ -11042,52 +10574,29 @@ func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
       glb.WINDOW_LOCATION_SEARCH = url;
       glb.ROOT_ELEMENT_ATTRIBUTES = func.UI.utils.get_root_element_attributes();
 
-      const params_obj = func.common.getObjectFromUrl(
-        url,
-        glb.ROOT_ELEMENT_ATTRIBUTES
-      );
+      const params_obj = func.common.getObjectFromUrl(url, glb.ROOT_ELEMENT_ATTRIBUTES);
       if (!params_obj.prog) {
-        return console.warn("prog empty");
+        return console.warn('prog empty');
       }
 
       await func.utils.TREE_OBJ.get(SESSION_ID, params_obj.prog);
-      let screen_ret = await func.utils.get_screen_obj(
-        SESSION_ID,
-        params_obj.prog
-      );
+      let screen_ret = await func.utils.get_screen_obj(SESSION_ID, params_obj.prog);
 
       if (screen_ret) {
-        await func.UI.screen.init(
-          SESSION_ID,
-          params_obj.prog,
-          null,
-          null,
-          $("#embed_" + SESSION_ID),
-          null,
-          null,
-          null,
-          null,
-          null,
-          "pendingUrlEvent_embed"
-        );
+        await func.UI.screen.init(SESSION_ID, params_obj.prog, null, null, $('#embed_' + SESSION_ID), null, null, null, null, null, 'pendingUrlEvent_embed');
       } else {
-        console.error("Program not exist", params_obj.prog_id);
-        func.UI.utils.progressScreen.show(
-          SESSION_ID,
-          "Program not exist",
-          null,
-          true
-        );
+        console.error('Program not exist', params_obj.prog_id);
+        func.UI.utils.progressScreen.show(SESSION_ID, 'Program not exist', null, true);
       }
     } else {
-      console.warn("url empty");
+      console.warn('url empty');
     }
   }
 };
 func.events.invoke = async function (event_id) {
   var _session = SESSION_OBJ[SESSION_ID];
   if (!event_id) {
-    console.warn("event_id Cannot be empty");
+    console.warn('event_id Cannot be empty');
     return false;
   }
   var ds;
@@ -11096,10 +10605,7 @@ func.events.invoke = async function (event_id) {
     if (_.isEmpty(_view_obj.progEvents)) continue;
     if (ds) break;
     for await (const [key, val] of Object.entries(_view_obj.progEvents)) {
-      if (
-        val?.data?.type === "user_defined" &&
-        val.data.event_name === event_id
-      ) {
+      if (val?.data?.type === 'user_defined' && val.data.event_name === event_id) {
         ds = ds_key;
         break;
       }
@@ -11107,11 +10613,11 @@ func.events.invoke = async function (event_id) {
   }
 
   if (!ds) {
-    console.warn("event_id not found");
+    console.warn('event_id not found');
     return false;
   }
 
-  func.events.validate(SESSION_ID, "user_defined", ds, event_id);
+  func.events.validate(SESSION_ID, 'user_defined', ds, event_id);
 };
  func.expression = {};
 
@@ -13364,8 +12870,8 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
     'xu-on': async function ($elm, val) {
       CLIENT_ACTIVITY_TS = Date.now();
       const trigger = val.key.split('xu-on:')[1].toLowerCase();
-      $elm.on(trigger, async function (e) {
-        for await (const [key, val] of Object.entries($elm.data().xuAttributes['xu-on:' + e.type])) {
+      $elm.on(trigger, async function (evt) {
+        for await (const [key, val] of Object.entries($elm.data().xuAttributes['xu-on:' + evt.type])) {
           if (val.handler === 'custom') {
             // do BL
             for await (const [key2, val2] of Object.entries(val.event)) {
@@ -13376,11 +12882,11 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
               }
               if (!cond) continue;
 
-              if (val.event_modifiers && e[val.event_modifiers]) {
-                e[val.event_modifiers]();
+              if (val.event_modifiers && evt[val.event_modifiers]) {
+                evt[val.event_modifiers]();
               }
 
-              func.events.add_to_queue(SESSION_ID, 'element event', val2.id, e.type, val2.data.action, val2.data.name, null, $elm.attr('xu-ui-id'), null, null, null, null, null, paramsP.dsSessionP, null, null, null, e.type, val2.data.name, null, null, val2, null, null, null, null, null, null);
+              func.events.add_to_queue(SESSION_ID, 'element event', val2.id, e.type, val2.data.action, val2.data.name, null, $elm.attr('xu-ui-id'), null, evt, null, null, null, paramsP.dsSessionP, null, null, null, e.type, val2.data.name, null, null, val2, null, null, null, null, null, null);
             }
           }
         }