@xuda.io/runtime-bundle 1.0.286 → 1.0.287

package/js/xuda-runtime-slim.js

@@ -3263,15 +3263,15 @@ func.datasource.create = async function (
   parameters_obj_inP,
   static_refreshP,
   worker_id,
-  NA_eventChangesResults
+  NA_eventChangesResults,
 ) {
   return new Promise(async function (resolve, reject) {
-    if (!prog_id) return reject("Program is empty");
+    if (!prog_id) return reject('Program is empty');
 
     var _session = SESSION_OBJ[SESSION_ID];
-    if (!_session.DS_GLB) return reject("DS_GLB not exist");
+    if (!_session.DS_GLB) return reject('DS_GLB not exist');
     var _prog_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, prog_id);
-    if (!_prog_obj) return reject("Program not found");
+    if (!_prog_obj) return reject('Program not found');
 
     var args = {
       SESSION_ID,
@@ -3303,8 +3303,7 @@ func.datasource.create = async function (
         old_dataSource_vars.SYS_STR_WIN_ID = _ds.data_system.SYS_STR_WIN_ID;
         old_dataSource_vars.SYS_STR_WIN_NAME = _ds.data_system.SYS_STR_WIN_NAME;
       }
-      if (static_refreshP)
-        old_dataSource_vars.in_parameters = _ds.in_parameters;
+      if (static_refreshP) old_dataSource_vars.in_parameters = _ds.in_parameters;
     }
     const restore_old_dataSource_vars = function (dsSessionP) {
       var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
@@ -3316,26 +3315,20 @@ func.datasource.create = async function (
         _ds.data_system.SYS_STR_WIN_NAME = old_dataSource_vars.SYS_STR_WIN_NAME;
       }
 
-      if (static_refreshP)
-        _ds.in_parameters = old_dataSource_vars.in_parameters;
+      if (static_refreshP) _ds.in_parameters = old_dataSource_vars.in_parameters;
     };
 
     var run_at = _prog_obj?.properties?.runAt;
-    if (_session.opt.app_computing_mode === "main") {
-      run_at = "client";
+    if (_session.opt.app_computing_mode === 'main') {
+      run_at = 'client';
     }
 
-    if (_prog_obj?.properties.menuType === "globals") {
-      run_at = "client";
+    if (_prog_obj?.properties.menuType === 'globals') {
+      run_at = 'client';
     }
 
-    if (
-      !run_at &&
-      parentDataSourceNoP &&
-      _session.DS_GLB[parentDataSourceNoP]
-    ) {
-      if (_session.DS_GLB[parentDataSourceNoP]._run_at)
-        run_at = _session.DS_GLB[parentDataSourceNoP].v.run_at;
+    if (!run_at && parentDataSourceNoP && _session.DS_GLB[parentDataSourceNoP]) {
+      if (_session.DS_GLB[parentDataSourceNoP]._run_at) run_at = _session.DS_GLB[parentDataSourceNoP].v.run_at;
     }
 
     const done = function (SESSION_ID, dsSessionP, is_serverP) {
@@ -3347,12 +3340,7 @@ func.datasource.create = async function (
 
       if (!IS_DATASOURCE_REFRESH) {
         if (!glb.IS_WORKER) {
-          DATASOURCE_INTERVALS[SESSION_ID][dsSessionP] =
-            new func.datasource.interval(
-              SESSION_ID,
-              dsSessionP,
-              "client_interval"
-            );
+          DATASOURCE_INTERVALS[SESSION_ID][dsSessionP] = new func.datasource.interval(SESSION_ID, dsSessionP, 'client_interval');
           DATASOURCE_INTERVALS[SESSION_ID][dsSessionP].init();
         }
       }
@@ -3367,8 +3355,8 @@ func.datasource.create = async function (
 
         var datasource_changes = {
           [dsSessionP]: {
-            ["datasource_main"]: {
-              stat: "idle",
+            ['datasource_main']: {
+              stat: 'idle',
               stat_ts: Date.now(),
               is_worker: glb.IS_WORKER,
             },
@@ -3382,7 +3370,7 @@ func.datasource.create = async function (
         let interval = setInterval(() => {
           let idle_count = 0;
           for (const _ds of ds_connected) {
-            if (_ds.stat == "idle") {
+            if (_ds.stat == 'idle') {
               idle_count++;
             }
           }
@@ -3411,12 +3399,7 @@ func.datasource.create = async function (
     if (jobNoP) {
     }
 
-    if (
-      glb.IS_WORKER ||
-      run_at === "client" ||
-      is_system_client_vars ||
-      db_driver === "pouchdb"
-    ) {
+    if (glb.IS_WORKER || run_at === 'client' || is_system_client_vars || db_driver === 'pouchdb') {
       const ret = await func.datasource.prepare(
         args.SESSION_ID,
         args.prog_id,
@@ -3435,7 +3418,7 @@ func.datasource.create = async function (
         args.parameters_obj_inP,
         args.static_refreshP,
         run_at,
-        worker_id
+        worker_id,
       );
       return done(SESSION_ID, ret.dsSessionP);
     }
@@ -3444,19 +3427,16 @@ func.datasource.create = async function (
     var data = _.assignIn(
       {
         session_id: SESSION_ID,
-        dataSourceSessionGlobal:
-          SESSION_OBJ[SESSION_ID].dataSourceSessionGlobal,
-        parentDataSourceNo: IS_DATASOURCE_REFRESH
-          ? _ds.parentDataSourceNo
-          : null,
+        dataSourceSessionGlobal: SESSION_OBJ[SESSION_ID].dataSourceSessionGlobal,
+        parentDataSourceNo: IS_DATASOURCE_REFRESH ? _ds.parentDataSourceNo : null,
         IS_DATASOURCE_REFRESH,
       },
-      args
+      args,
     );
     delete data.SESSION_ID;
 
     const jsonP = await func.index.call_worker(SESSION_ID, {
-      service: "datasource_create",
+      service: 'datasource_create',
       data,
       id: SESSION_OBJ[SESSION_ID].worker_id,
     });
@@ -3470,43 +3450,20 @@ func.datasource.create = async function (
     return done(SESSION_ID, jsonP.dsSession, true);
   });
 };
-func.datasource.prepare = async function (
-  SESSION_ID,
-  prog_id,
-  dataSourceNoP,
-  parentDataSourceNoP,
-  containerIdP,
-  rowIdP,
-  jobNoP,
-  calling_trigger_prop,
-  NA_screen_param,
-  NA_isInitP,
-  callingSourceP,
-  calling_jobP,
-  NA_screen_dsP,
-  is_panelP,
-  parameters_obj_inP,
-  static_refreshP,
-  run_atP,
-  worker_id
-) {
+func.datasource.prepare = async function (SESSION_ID, prog_id, dataSourceNoP, parentDataSourceNoP, containerIdP, rowIdP, jobNoP, calling_trigger_prop, NA_screen_param, NA_isInitP, callingSourceP, calling_jobP, NA_screen_dsP, is_panelP, parameters_obj_inP, static_refreshP, run_atP, worker_id) {
   const set_parameters = async function () {
     var _session = SESSION_OBJ[SESSION_ID];
-    const get_Out_parameters = async function (
-      fieldIdP,
-      located_field_param_idxP,
-      param_row_idP
-    ) {
+    const get_Out_parameters = async function (fieldIdP, located_field_param_idxP, param_row_idP) {
       var ret = parameters_obj_inP?.[fieldIdP] || fieldIdP;
 
-      PARAM_OUT_INFO[prog_id + "_" + param_row_idP] = {
+      PARAM_OUT_INFO[prog_id + '_' + param_row_idP] = {
         module: _ds.viewModule,
-        action: "parameters",
-        prop: "out",
+        action: 'parameters',
+        prop: 'out',
         details: ret,
         result: ret,
         source: _ds.viewSourceDesc,
-        type: "parameters",
+        type: 'parameters',
         prog_id: prog_id,
         dsSession: dataSourceSession,
         fieldId: fieldIdP,
@@ -3525,34 +3482,24 @@ func.datasource.prepare = async function (
         _ds.in_parameters = {};
         _ds.out_parameters = {};
 
-        for await (let [key, val] of Object.entries(
-          screenInfo.properties?.progParams
-        )) {
+        for await (let [key, val] of Object.entries(screenInfo.properties?.progParams)) {
           // run on parameters arr
-          if (val.data.dir === "in") {
+          if (val.data.dir === 'in') {
             _ds.in_parameters[val.data.parameter] = {
               // value: parameters_obj_inP?.[val.data.parameter],
               type: val.data.type,
             };
 
-            if (
-              typeof parameters_obj_inP?.[val.data.parameter] !== "undefined"
-            ) {
-              _ds.in_parameters[val.data.parameter].value =
-                parameters_obj_inP[val.data.parameter];
-            } else if (_session.engine_mode === "live_preview") {
-              _ds.in_parameters[val.data.parameter].value =
-                _session?.url_params?.[val.data.parameter];
+            if (typeof parameters_obj_inP?.[val.data.parameter] !== 'undefined') {
+              _ds.in_parameters[val.data.parameter].value = parameters_obj_inP[val.data.parameter];
+            } else if (_session.engine_mode === 'live_preview') {
+              _ds.in_parameters[val.data.parameter].value = _session?.url_params?.[val.data.parameter];
             }
 
             continue;
           }
-          if (val.data.dir === "out" && val.data.parameter) {
-            _ds.out_parameters[val.data.parameter] = await get_Out_parameters(
-              val.data.parameter,
-              key,
-              val.id
-            );
+          if (val.data.dir === 'out' && val.data.parameter) {
+            _ds.out_parameters[val.data.parameter] = await get_Out_parameters(val.data.parameter, key, val.id);
           }
         }
 
@@ -3562,23 +3509,20 @@ func.datasource.prepare = async function (
   };
   const build_GLOBAL_SYS_fields = function () {
     if (!_ds.data_system) _ds.data_system = {};
-    _ds.data_system["SYS_GLOBAL_UTC"] = -new Date().getTimezoneOffset() / 60;
-    _ds.data_system["SYS_GLOBAL_STR_APP_ID"] = APP_OBJ[_session.app_id]._id;
-    _ds.data_system["SYS_GLOBAL_STR_SESSION_ID"] = SESSION_ID;
-    _ds.data_system["SYS_GLOBAL_STR_LOGIN_USER_ID"] = _session.USR_OBJ._id;
+    _ds.data_system['SYS_GLOBAL_UTC'] = -new Date().getTimezoneOffset() / 60;
+    _ds.data_system['SYS_GLOBAL_STR_APP_ID'] = APP_OBJ[_session.app_id]._id;
+    _ds.data_system['SYS_GLOBAL_STR_SESSION_ID'] = SESSION_ID;
+    _ds.data_system['SYS_GLOBAL_STR_LOGIN_USER_ID'] = _session.USR_OBJ._id;
 
-    if (
-      _session.engine_mode !== "live_preview" &&
-      PROJECT_OBJ[_session.app_id].info
-    ) {
-      _ds.data_system["SYS_GLOBAL_OBJ_APP_INFO"] = {
+    if (_session.engine_mode !== 'live_preview' && PROJECT_OBJ[_session.app_id].info) {
+      _ds.data_system['SYS_GLOBAL_OBJ_APP_INFO'] = {
         build: PROJECT_OBJ[_session.app_id].info.build_id,
         author: PROJECT_OBJ[_session.app_id].info.author,
         date: PROJECT_OBJ[_session.app_id].info.build_date,
         name: APP_OBJ[_session.app_id].app_name,
       };
     }
-    _ds.data_system["SYS_GLOBAL_OBJ_LOGIN_USER_INFO"] = {
+    _ds.data_system['SYS_GLOBAL_OBJ_LOGIN_USER_INFO'] = {
       id: _session.USR_OBJ._id,
       user_name: _session.USR_OBJ.usr_name,
       first_name: _session.USR_OBJ.usr_first_name,
@@ -3586,52 +3530,37 @@ func.datasource.prepare = async function (
       email: _session.USR_OBJ.usr_email,
       profile_picture: _session.USR_OBJ.usr_profile_picture,
     };
-    _ds.data_system["SYS_GLOBAL_STR_BROWSER_HASH_ID"] =
-      _session.SYS_GLOBAL_STR_BROWSER_HASH_ID;
-    _ds.data_system["SYS_GLOBAL_STR_BROWSER_TITLE"] =
-      _session.SYS_GLOBAL_STR_BROWSER_TITLE;
+    _ds.data_system['SYS_GLOBAL_STR_BROWSER_HASH_ID'] = _session.SYS_GLOBAL_STR_BROWSER_HASH_ID;
+    _ds.data_system['SYS_GLOBAL_STR_BROWSER_TITLE'] = _session.SYS_GLOBAL_STR_BROWSER_TITLE;
     // }
-    _ds.data_system["SYS_GLOBAL_STR_SITE_CSS"] = {};
-    _ds.data_system["SYS_GLOBAL_BOL_SHIFT_KEY_STATE"] = 0;
-    _ds.data_system["SYS_GLOBAL_BOL_COMMAND_KEY_STATE"] = 0;
-    _ds.data_system["SYS_GLOBAL_BOL_CONTROL_KEY_STATE"] = 0;
-    _ds.data_system["SYS_GLOBAL_BOL_ALT_KEY_STATE"] = 0;
+    _ds.data_system['SYS_GLOBAL_STR_SITE_CSS'] = {};
+    _ds.data_system['SYS_GLOBAL_BOL_SHIFT_KEY_STATE'] = 0;
+    _ds.data_system['SYS_GLOBAL_BOL_COMMAND_KEY_STATE'] = 0;
+    _ds.data_system['SYS_GLOBAL_BOL_CONTROL_KEY_STATE'] = 0;
+    _ds.data_system['SYS_GLOBAL_BOL_ALT_KEY_STATE'] = 0;
 
-    _ds.data_system["SYS_GLOBAL_BOL_ONLINE"] = 0;
-    _ds.data_system["SYS_GLOBAL_BOL_REPLICATION_STAT"] = 0;
-    _ds.data_system["SYS_GLOBAL_BOL_AJAX_BUSY"] = 0;
-    _ds.data_system["SYS_GLOBAL_BOL_CONNECTED"] = 1;
-    _ds.data_system["SYS_GLOBAL_BOL_IDLE"] = 0;
+    _ds.data_system['SYS_GLOBAL_BOL_ONLINE'] = 0;
+    _ds.data_system['SYS_GLOBAL_BOL_REPLICATION_STAT'] = 0;
+    _ds.data_system['SYS_GLOBAL_BOL_AJAX_BUSY'] = 0;
+    _ds.data_system['SYS_GLOBAL_BOL_CONNECTED'] = 1;
+    _ds.data_system['SYS_GLOBAL_BOL_IDLE'] = 0;
 
-    _ds.data_system["SYS_GLOBAL_STR_FIREBASE_TOKEN_ID"] = 0;
+    _ds.data_system['SYS_GLOBAL_STR_FIREBASE_TOKEN_ID'] = 0;
 
-    _ds.data_system["SYS_GLOBAL_BOL_PUSH_NOTIFICATION_GRANTED"] =
-      _session.PUSH_NOTIFICATION_GRANTED;
+    _ds.data_system['SYS_GLOBAL_BOL_PUSH_NOTIFICATION_GRANTED'] = _session.PUSH_NOTIFICATION_GRANTED;
 
-    _ds.data_system["SYS_GLOBAL_OBJ_FIREBASE_AUTH_INFO"] =
-      _session.SYS_GLOBAL_OBJ_FIREBASE_AUTH_INFO;
+    _ds.data_system['SYS_GLOBAL_OBJ_FIREBASE_AUTH_INFO'] = _session.SYS_GLOBAL_OBJ_FIREBASE_AUTH_INFO;
 
-    _ds.data_system["SYS_GLOBAL_OBJ_CLIENT_INFO"] =
-      _session.SYS_GLOBAL_OBJ_CLIENT_INFO;
+    _ds.data_system['SYS_GLOBAL_OBJ_CLIENT_INFO'] = _session.SYS_GLOBAL_OBJ_CLIENT_INFO;
   };
   if (!SESSION_OBJ[SESSION_ID].DS_GLB) return;
 
   if (dataSourceNoP && !SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceNoP]) {
-    return func.utils.debug_report(
-      SESSION_ID,
-      "Datasource",
-      "Datasource not exist: " + dataSourceNoP,
-      "E"
-    );
+    return func.utils.debug_report(SESSION_ID, 'Datasource', 'Datasource not exist: ' + dataSourceNoP, 'E');
   }
 
   if (!prog_id) {
-    return func.utils.debug_report(
-      SESSION_ID,
-      "Datasource",
-      "Program is null",
-      "E"
-    );
+    return func.utils.debug_report(SESSION_ID, 'Datasource', 'Program is null', 'E');
   }
 
   const args = {
@@ -3657,18 +3586,13 @@ func.datasource.prepare = async function (
 
   const init_dataSource = async function () {
     const init_new_dataSource = async function () {
-      if (
-        !["main"].includes(SESSION_OBJ[SESSION_ID].opt.app_computing_mode) &&
-        run_atP === "client" &&
-        prog_id !== "system"
-      ) {
+      if (!['main'].includes(SESSION_OBJ[SESSION_ID].opt.app_computing_mode) && run_atP === 'client' && prog_id !== 'system') {
         const ret = await func.index.call_worker(SESSION_ID, {
-          service: "get_dataSourceSessionGlobal",
+          service: 'get_dataSourceSessionGlobal',
           data: { session_id: SESSION_ID },
           id: SESSION_OBJ[SESSION_ID].worker_id,
         });
-        SESSION_OBJ[SESSION_ID].dataSourceSessionGlobal =
-          ret?.new_dataSourceSessionGlobal || 1;
+        SESSION_OBJ[SESSION_ID].dataSourceSessionGlobal = ret?.new_dataSourceSessionGlobal || 1;
       } else {
         SESSION_OBJ[SESSION_ID].dataSourceSessionGlobal++;
       }
@@ -3679,7 +3603,7 @@ func.datasource.prepare = async function (
     };
     const init_existing_dataSource = function () {
       let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceNoP];
-      console.log("DATASOURCE_REFRESH", dataSourceNoP);
+      console.log('DATASOURCE_REFRESH', dataSourceNoP);
       IS_DATASOURCE_REFRESH = true;
       _ds.refreshed = true;
       try {
@@ -3692,13 +3616,13 @@ func.datasource.prepare = async function (
 
         _ds.v.old_dataSource = _.cloneDeep(_ds);
       } catch (err) {
-        console.error("function: init_existing_dataSource - error");
+        console.error('function: init_existing_dataSource - error');
         return;
       }
       dataSourceSession = dataSourceNoP;
     };
 
-    if (typeof dataSourceNoP === "undefined" || dataSourceNoP === null) {
+    if (typeof dataSourceNoP === 'undefined' || dataSourceNoP === null) {
       await init_new_dataSource();
     } else {
       init_existing_dataSource();
@@ -3708,7 +3632,7 @@ func.datasource.prepare = async function (
   };
   var _ds = await init_dataSource();
 
-  _ds.stat = "busy";
+  _ds.stat = 'busy';
   _ds._run_at = run_atP;
   // init_v();
 
@@ -3720,12 +3644,7 @@ func.datasource.prepare = async function (
   _ds.tree_obj = await func.utils.TREE_OBJ.get(SESSION_ID, prog_id);
 
   if (!_ds.tree_obj) {
-    return func.utils.debug_report(
-      SESSION_ID,
-      "Datasource",
-      "Program not exist: " + prog_id,
-      "E"
-    );
+    return func.utils.debug_report(SESSION_ID, 'Datasource', 'Program not exist: ' + prog_id, 'E');
   }
 
   await func.datasource.set_VIEW_data(SESSION_ID, args, _ds);
@@ -3735,7 +3654,7 @@ func.datasource.prepare = async function (
   ) {
     _ds.v.viewSourceDesc = callingSourceP;
   }
-  if (dataSourceSession === 0) _ds.v.viewSourceDesc = "system startup";
+  if (dataSourceSession === 0) _ds.v.viewSourceDesc = 'system startup';
   var _session = SESSION_OBJ[SESSION_ID];
 
   const set_DS_GLB = async function () {
@@ -3761,7 +3680,7 @@ func.datasource.prepare = async function (
   await set_DS_GLB();
 
   if (
-    prog_id === "system" &&
+    prog_id === 'system' &&
     !parentDataSourceNoP // do only on first time datasource 0 call
   ) {
     build_GLOBAL_SYS_fields();
@@ -3776,18 +3695,10 @@ func.datasource.prepare = async function (
   //  INTERVALS
   //======================================
 
-  _ds.client_interval = func.datasource.get_event_interval_arr(
-    SESSION_ID,
-    dataSourceSession,
-    "client_interval"
-  );
+  _ds.client_interval = func.datasource.get_event_interval_arr(SESSION_ID, dataSourceSession, 'client_interval');
 
-  if (prog_id === "system") {
-    _ds.server_interval = func.datasource.get_event_interval_arr(
-      SESSION_ID,
-      dataSourceSession,
-      "server_interval"
-    );
+  if (prog_id === 'system') {
+    _ds.server_interval = func.datasource.get_event_interval_arr(SESSION_ID, dataSourceSession, 'server_interval');
   }
 
   // if (static_refreshP) {
@@ -3796,22 +3707,14 @@ func.datasource.prepare = async function (
   // if (!static_refreshP) await set_parameters(); // do only on new datasource or refresh
 
   // try {
-  let ret_execute = await func.datasource.execute(
-    SESSION_ID,
-    dataSourceSession
-  );
+  let ret_execute = await func.datasource.execute(SESSION_ID, dataSourceSession);
   return ret_execute;
   // } catch (e) {
   //   console.error(e);
   // }
 };
 
-func.datasource.execute = async function (
-  SESSION_ID,
-  dataSourceSession,
-  IS_DATASOURCE_REFRESH
-) {
-
+func.datasource.execute = async function (SESSION_ID, dataSourceSession, IS_DATASOURCE_REFRESH) {
   var _session = SESSION_OBJ[SESSION_ID];
   var _ds = _session.DS_GLB[dataSourceSession];
   var args = _ds.args;
@@ -3820,60 +3723,32 @@ func.datasource.execute = async function (
   let prog_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
 
   const callback_datasource = async function () {
-    if (typeof IS_WORKER === "undefined" && typeof IS_DOCKER === "undefined" &&
-      typeof IS_PROCESS_SERVER === "undefined" && _ds.viewSourceProp === "globals") {
-
-      if (!["main"].includes(_session.opt.app_computing_mode)) {
+    if (typeof IS_WORKER === 'undefined' && typeof IS_DOCKER === 'undefined' && typeof IS_PROCESS_SERVER === 'undefined' && _ds.viewSourceProp === 'globals') {
+      if (!['main'].includes(_session.opt.app_computing_mode)) {
         await func.index.call_worker(SESSION_ID, {
-          service: "create_webworker_globals",
+          service: 'create_webworker_globals',
           data: { ds_data: _ds, session_id: SESSION_ID },
         });
       }
     }
 
-    if (
-      await func.datasource.get_view_events_count(
-        SESSION_ID,
-        dataSourceSession,
-        "on_load"
-      )
-    ) {
-      await func.datasource.execute_view_events(
-        SESSION_ID,
-        dataSourceSession,
-        "on_load"
-      );
+    if (await func.datasource.get_view_events_count(SESSION_ID, dataSourceSession, 'on_load')) {
+      await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'on_load');
     }
     // }
-    return func.datasource.callback(
-      SESSION_ID,
-      dataSourceSession,
-      args.dataSourceNoP,
-      args.rowIdP,
-      args.jobNoP,
-      null,
-      _ds.prog_id
-    );
+    return await func.datasource.callback(SESSION_ID, dataSourceSession, args.dataSourceNoP, args.rowIdP, args.jobNoP, null, _ds.prog_id);
   };
 
   const get_limit = async function () {
     var ret = 0;
     let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
-    if (tree_ret.menuType === "get_data") {
+    if (tree_ret.menuType === 'get_data') {
       return 1;
     }
     ret = _ds.progDataSource?.dataSourceLimit;
 
     if (prog_obj.progDataSource?.dataSourceLoopExp) {
-      ret = (
-        await func.expression.get(
-          SESSION_ID,
-          prog_obj.progDataSource.dataSourceLoopExp,
-          dataSourceSession,
-          "view_loop",
-          args.rowIdP
-        )
-      ).result;
+      ret = (await func.expression.get(SESSION_ID, prog_obj.progDataSource.dataSourceLoopExp, dataSourceSession, 'view_loop', args.rowIdP)).result;
     }
     return ret;
   };
@@ -3883,24 +3758,13 @@ func.datasource.execute = async function (
     ret = _ds.progDataSource?.dataSourceSkip;
 
     if (prog_obj.progDataSource?.dataSourceSkipExp) {
-      ret = (
-        await func.expression.get(
-          SESSION_ID,
-          prog_obj.progDataSource.dataSourceSkipExp,
-          dataSourceSession,
-          "view_loop",
-          args.rowIdP
-        )
-      ).result;
+      ret = (await func.expression.get(SESSION_ID, prog_obj.progDataSource.dataSourceSkipExp, dataSourceSession, 'view_loop', args.rowIdP)).result;
     }
     return ret;
   };
 
   const calc_batch_loops = async () => {
-    if (
-      !prog_obj.progDataSource?.dataSourceType ||
-      _ds.progDataSource.dataSourceType === "none"
-    ) {
+    if (!prog_obj.progDataSource?.dataSourceType || _ds.progDataSource.dataSourceType === 'none') {
       _ds.v.batch_loops = await get_limit();
       return false;
     }
@@ -3909,10 +3773,7 @@ func.datasource.execute = async function (
     //     ? await get_limit()
     //     : _ds?.data_feed?.rows?.length;
 
-    _ds.v.batch_loops =
-      (await get_limit()) <= _ds.v.raw_data?.rows?.length
-        ? await get_limit()
-        : _ds.v.raw_data?.rows?.length;
+    _ds.v.batch_loops = (await get_limit()) <= _ds.v.raw_data?.rows?.length ? await get_limit() : _ds.v.raw_data?.rows?.length;
     return true;
     // _ds.v.batch_loops =
     //   (await get_limit()) <= _ds.v?.raw_data?.rows?.length
@@ -3923,54 +3784,39 @@ func.datasource.execute = async function (
 
   const render_api_output = async function () {
     if (prog_obj?.scriptData?.value) {
-      var exp = await func.expression.get(
-        SESSION_ID,
-        prog_obj.scriptData.value,
-        dataSourceSession,
-        "api_rendered_output",
-        null, null, null, null, null, null, null, null, null, tree_obj.apiOutput
-      );
+      var exp = await func.expression.get(SESSION_ID, prog_obj.scriptData.value, dataSourceSession, 'api_rendered_output', null, null, null, null, null, null, null, null, null, tree_obj.apiOutput);
 
-      let output_result = exp.result
-      if (tree_obj.apiOutput === "json") {
+      let output_result = exp.result;
+      if (tree_obj.apiOutput === 'json') {
         // iterate object to fix expressions
         try {
           // let output_result_obj = JSON5.parse(output_result)
-          let output_result_obj = await func.expression.secure_eval(
-            SESSION_ID,
-            "api_rendered_output",
-            "(" + output_result + ")",
-            null,
-            dataSourceSession,
-
-          );
+          let output_result_obj = await func.expression.secure_eval(SESSION_ID, 'api_rendered_output', '(' + output_result + ')', null, dataSourceSession);
           // for await (let [key, val] of Object.entries(output_result_obj)) {
           //   output_result_obj[key] = (await func.expression.get(
           //     SESSION_ID,
           //     val,
           //     dataSourceSession, "object_property")).result
           // }
-          output_result = JSON.stringify(output_result_obj)
+          output_result = JSON.stringify(output_result_obj);
         } catch (err) {
-          console.error(err)
+          console.error(err);
         }
-
       }
-      _ds.api_rendered_output +=
-        output_result + (tree_obj.apiOutput === "json" ? "," : "");
+      _ds.api_rendered_output += output_result + (tree_obj.apiOutput === 'json' ? ',' : '');
     } else {
-      _ds.api_rendered_output = ""; //empty
+      _ds.api_rendered_output = ''; //empty
     }
   };
 
   // ======================================
   // COMPUTE GLOBALS
   // ======================================
-  if (_ds.prog_id === "system") {
+  if (_ds.prog_id === 'system') {
     //TBD tree_obj.menuType === "globals"
-    _ds.currentRecordId = "dataset";
+    _ds.currentRecordId = 'dataset';
     await func.datasource.render_fields_dataset(SESSION_ID, dataSourceSession, {
-      id: "dataset",
+      id: 'dataset',
       value: _session.url_params,
     });
 
@@ -3983,47 +3829,31 @@ func.datasource.execute = async function (
   let db_adapter_module;
 
   if (prog_obj.progDataSource?.dataSourceType) {
-    db_adapter_module = await func.common.get_module(
-      SESSION_ID,
-      "xuda-datasource-db-adapter-module.mjs"
-    );
+    db_adapter_module = await func.common.get_module(SESSION_ID, 'xuda-datasource-db-adapter-module.mjs');
   }
 
   const get_data_from_source = async function () {
     switch (prog_obj.progDataSource.dataSourceSrcType) {
-      case "input": {
-        const { result, error } = await func.expression.get(
-          SESSION_ID,
-          prog_obj.progDataSource.progDataSourceInput,
-          dataSourceSession,
-          "datasource select"
-        );
+      case 'input': {
+        const { result, error } = await func.expression.get(SESSION_ID, prog_obj.progDataSource.progDataSourceInput, dataSourceSession, 'datasource select');
         if (error) {
-          func.utils.debug_report(
-            SESSION_ID,
-            "Data source",
-            `Datasource parse error using ${prog_obj.progDataSource?.dataSourceType} input`,
-            "E"
-          );
+          func.utils.debug_report(SESSION_ID, 'Data source', `Datasource parse error using ${prog_obj.progDataSource?.dataSourceType} input`, 'E');
           return null;
         }
 
         return result;
         break;
       }
-      case "url": {
+      case 'url': {
         let opt = {
-          method: prog_obj.progDataSource.dataSourceMethod || "POST",
+          method: prog_obj.progDataSource.dataSourceMethod || 'POST',
           headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
           },
         };
         let data = {};
-        if (
-          prog_obj.progDataSource.dataSourceMethod == "POST" &&
-          prog_obj.progDataSource.dataSourceParameters
-        ) {
+        if (prog_obj.progDataSource.dataSourceMethod == 'POST' && prog_obj.progDataSource.dataSourceParameters) {
           for (let val of prog_obj.progDataSource.dataSourceParameters) {
             data[val.key] = val.val;
           }
@@ -4031,21 +3861,11 @@ func.datasource.execute = async function (
           opt.body = JSON.stringify(data);
         }
         try {
-          const response = await fetch(
-            "https://" + prog_obj.progDataSource.dataSourceDataUrl,
-            opt
-          );
+          const response = await fetch('https://' + prog_obj.progDataSource.dataSourceDataUrl, opt);
           const json = await response.json();
           return json.data;
         } catch (err) {
-          func.utils.debug_report(
-            SESSION_ID,
-            "Data source",
-            err.message +
-            " https://" +
-            prog_obj.progDataSource.dataSourceDataUrl,
-            "E"
-          );
+          func.utils.debug_report(SESSION_ID, 'Data source', err.message + ' https://' + prog_obj.progDataSource.dataSourceDataUrl, 'E');
           return null;
         }
 
@@ -4065,76 +3885,37 @@ func.datasource.execute = async function (
   _ds.data_feed.rows = [];
 
   switch (prog_obj.progDataSource?.dataSourceType) {
-    case "table":
+    case 'table':
       _ds._dataSourceTableId = prog_obj.progDataSource?.dataSourceTableId; // get file id
 
       if (prog_obj.progDataSource?.dataSourceTableIdExp) {
-        _ds.v.dataSourceTableIdExp = await func.expression.get(
-          SESSION_ID,
-          prog_obj.progDataSource?.dataSourceTableIdExp,
-          dataSourceSession,
-          "dataSourceTableIdExp",
-          args.rowIdP
-        );
+        _ds.v.dataSourceTableIdExp = await func.expression.get(SESSION_ID, prog_obj.progDataSource?.dataSourceTableIdExp, dataSourceSession, 'dataSourceTableIdExp', args.rowIdP);
         if (_ds.v.dataSourceTableIdExp.result) {
           _ds._dataSourceTableId = _ds.v.dataSourceTableIdExp.result;
         } else {
-          func.utils.debug_report(
-            SESSION_ID,
-            "get_VIEW_data",
-            "Table Expression returned empty result",
-            "W"
-          );
+          func.utils.debug_report(SESSION_ID, 'get_VIEW_data', 'Table Expression returned empty result', 'W');
         }
       }
 
       if (!_ds._dataSourceTableId) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Data source",
-          "Table cannot be empty when Db Table selected",
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Data source', 'Table cannot be empty when Db Table selected', 'E');
       }
 
-      let table_ret = await func.utils.TREE_OBJ.get(
-        SESSION_ID,
-        _ds._dataSourceTableId
-      );
+      let table_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds._dataSourceTableId);
       if (!table_ret) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Data source",
-          "Table not found: " + _ds._dataSourceTableId,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Data source', 'Table not found: ' + _ds._dataSourceTableId, 'E');
       }
 
-      await db_adapter_module.build_filter(
-        SESSION_ID,
-        dataSourceSession,
-        _ds.v,
-        _ds
-      );
+      await db_adapter_module.build_filter(SESSION_ID, dataSourceSession, _ds.v, _ds);
 
       let filterModelMongo = _ds.progDataSource.filterModelMongo;
       if (_ds.progDataSource.filterModelMongoFx) {
-        let ret = await func.expression.get(
-          SESSION_ID,
-          _ds.progDataSource.filterModelMongoFx,
-          dataSourceSession,
-          "query"
-        );
+        let ret = await func.expression.get(SESSION_ID, _ds.progDataSource.filterModelMongoFx, dataSourceSession, 'query');
         filterModelMongo = ret.result;
       }
       let filterModelSql = _ds.progDataSource.filterModelSql;
       if (_ds.progDataSource.filterModelSqlFx) {
-        let ret = await func.expression.get(
-          SESSION_ID,
-          _ds.progDataSource.filterModelSqlFx,
-          dataSourceSession,
-          "query"
-        );
+        let ret = await func.expression.get(SESSION_ID, _ds.progDataSource.filterModelSqlFx, dataSourceSession, 'query');
         filterModelSql = ret.result;
       }
 
@@ -4154,7 +3935,7 @@ func.datasource.execute = async function (
         _ds.v.couchView,
         dataSourceSession,
         _ds.viewSourceDesc,
-        "datasource table",
+        'datasource table',
         prog_obj.progDataSource.dataSourceReduce,
         await get_skip(),
         (await get_limit()) || 99999999,
@@ -4163,7 +3944,7 @@ func.datasource.execute = async function (
         _ds?.progDataSource?.sortModel,
         null,
         filterModel,
-        _ds?.progDataSource?.dataSourceFilterModelType
+        _ds?.progDataSource?.dataSourceFilterModelType,
       );
       if (_ds?.progDataSource?.dataSourceLimit) {
         const ret_rows_found = await func.db.get_query(
@@ -4172,7 +3953,7 @@ func.datasource.execute = async function (
           _ds.v.couchView,
           dataSourceSession,
           _ds.viewSourceDesc,
-          "datasource table",
+          'datasource table',
           prog_obj.progDataSource.dataSourceReduce,
           null,
           null,
@@ -4181,7 +3962,7 @@ func.datasource.execute = async function (
           null,
           null,
           filterModel,
-          _ds?.progDataSource?.dataSourceFilterModelType
+          _ds?.progDataSource?.dataSourceFilterModelType,
         );
         _ds.rows_found = ret_rows_found?.rows?.[0]?.value || 0;
       } else {
@@ -4189,7 +3970,7 @@ func.datasource.execute = async function (
       }
       break;
 
-    case "array": {
+    case 'array': {
       let data = await get_data_from_source();
 
       if (data === null) {
@@ -4215,7 +3996,7 @@ func.datasource.execute = async function (
       break;
     }
 
-    case "json": {
+    case 'json': {
       let data = await get_data_from_source();
       if (data === null) {
         data = {};
@@ -4236,12 +4017,10 @@ func.datasource.execute = async function (
       break;
     }
 
-
-
-    case "csv":
+    case 'csv':
       let data = await get_data_from_source();
       if (data === null) {
-        data = "";
+        data = '';
       }
 
       // if (!_ds.v.raw_data) {
@@ -4260,7 +4039,7 @@ func.datasource.execute = async function (
       // }
 
       let _KEY = 0;
-      let arr = data.split(",");
+      let arr = data.split(',');
       for (const _VAL of arr) {
         _ds.v.raw_data.rows.push({ id: _KEY, value: { _KEY, _VAL } });
         _KEY++;
@@ -4279,24 +4058,16 @@ func.datasource.execute = async function (
   let ret;
 
   const get_before_record_count = async () => {
-    return await func.datasource.get_view_events_count(
-      SESSION_ID,
-      dataSourceSession,
-      "before_record"
-    );
+    return await func.datasource.get_view_events_count(SESSION_ID, dataSourceSession, 'before_record');
   };
   const get_after_record_count = async () => {
-    return await func.datasource.get_view_events_count(
-      SESSION_ID,
-      dataSourceSession,
-      "after_record"
-    );
+    return await func.datasource.get_view_events_count(SESSION_ID, dataSourceSession, 'after_record');
   };
 
   let _raw_data_rows = [];
   switch (tree_obj.menuType) {
-    case "api": {
-      _ds.api_rendered_output = "";
+    case 'api': {
+      _ds.api_rendered_output = '';
       let has_datasource = await calc_batch_loops();
 
       _raw_data_rows = _ds.v.raw_data.rows || [];
@@ -4305,7 +4076,7 @@ func.datasource.execute = async function (
           _raw_data_rows.push({ id: n, value: {} });
         }
       }
-      _ds.currentRecordId = "dataset";
+      _ds.currentRecordId = 'dataset';
       for await (let [key, raw_data_row] of Object.entries(_raw_data_rows)) {
         if (has_datasource && Number(key) >= _ds.v.batch_loops) break;
 
@@ -4314,47 +4085,31 @@ func.datasource.execute = async function (
         }
 
         if (await get_before_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "before_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'before_record');
         }
 
-        await func.datasource.render_fields_dataset(
-          SESSION_ID,
-          dataSourceSession,
-          raw_data_row
-        );
+        await func.datasource.render_fields_dataset(SESSION_ID, dataSourceSession, raw_data_row);
 
         if (await get_after_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "after_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'after_record');
         }
 
         await render_api_output();
       }
 
-      if (tree_obj.apiOutput === "json") {
-        var str = _ds.api_rendered_output.substring(
-          0,
-          _ds.api_rendered_output.length - 1
-        );
+      if (tree_obj.apiOutput === 'json') {
+        var str = _ds.api_rendered_output.substring(0, _ds.api_rendered_output.length - 1);
         if (Number(_ds.progDataSource?.dataSourceLimit) === 1) {
           _ds.api_rendered_output = str;
         } else {
-          _ds.api_rendered_output = "[" + str + "]";
+          _ds.api_rendered_output = '[' + str + ']';
         }
       }
 
       break;
     }
 
-    case "batch": {
-
+    case 'batch': {
       let has_datasource = await calc_batch_loops();
 
       _raw_data_rows = _ds?.v.raw_data?.rows || [];
@@ -4363,7 +4118,7 @@ func.datasource.execute = async function (
           _raw_data_rows.push({ id: n, value: {} });
         }
       }
-      _ds.currentRecordId = "dataset";
+      _ds.currentRecordId = 'dataset';
       for await (let [key, raw_data_row] of Object.entries(_raw_data_rows)) {
         if (has_datasource && Number(key) >= _ds.v.batch_loops) break;
 
@@ -4372,68 +4127,35 @@ func.datasource.execute = async function (
         }
 
         if (await get_before_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "before_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'before_record');
         }
 
-        await func.datasource.render_fields_dataset(
-          SESSION_ID,
-          dataSourceSession,
-          raw_data_row
-        );
+        await func.datasource.render_fields_dataset(SESSION_ID, dataSourceSession, raw_data_row);
 
         if (await get_after_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "after_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'after_record');
         }
       }
       await func.datasource.set_outputField(SESSION_ID, dataSourceSession, _ds?.v?.raw_data?.rows, _ds.args);
       break;
     }
 
-    case "get_data":
+    case 'get_data':
       if (await get_before_record_count()) {
-        await func.datasource.execute_view_events(
-          SESSION_ID,
-          dataSourceSession,
-          "before_record"
-        );
+        await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'before_record');
       }
 
-      ret = await db_adapter_module.process_view_dataset(
-        SESSION_ID,
-        dataSourceSession,
-        _ds
-      );
+      ret = await db_adapter_module.process_view_dataset(SESSION_ID, dataSourceSession, _ds);
 
       if (await get_after_record_count()) {
-        await func.datasource.execute_view_events(
-          SESSION_ID,
-          dataSourceSession,
-          "after_record"
-        );
+        await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'after_record');
       }
       await func.datasource.set_outputField(SESSION_ID, dataSourceSession, _ds?.v?.raw_data?.rows, _ds.args);
       break;
 
-    case "set_data":
-      if (
-        !prog_obj.progDataSource?.dataSourceType ||
-        _ds.progDataSource.dataSourceType !== "table" ||
-        !_ds._dataSourceTableId
-      ) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Data source",
-          "Datasource DB Table must be defined for Set Data operation",
-          "E"
-        );
+    case 'set_data':
+      if (!prog_obj.progDataSource?.dataSourceType || _ds.progDataSource.dataSourceType !== 'table' || !_ds._dataSourceTableId) {
+        return func.utils.debug_report(SESSION_ID, 'Data source', 'Datasource DB Table must be defined for Set Data operation', 'E');
       }
 
       // const get_data_from_data_feed = function () {
@@ -4448,7 +4170,7 @@ func.datasource.execute = async function (
 
       const find_ROWID_idx_from_raw_data_arr = function (rowId) {
         if (!_raw_data_rows) {
-          throw new Error("_raw_data_rows not found");
+          throw new Error('_raw_data_rows not found');
         }
 
         const index = _raw_data_rows.findIndex((item) => item.id === rowId);
@@ -4458,81 +4180,62 @@ func.datasource.execute = async function (
         return index;
       };
 
-      if (tree_obj.crudMode === "U") {
-        _ds.set_mode = "U";
+      if (tree_obj.crudMode === 'U') {
+        _ds.set_mode = 'U';
         // _raw_data_rows = get_data_from_data_feed(); // _ds?.raw_data?.rows || [];
         _raw_data_rows = _ds?.v.raw_data?.rows || [];
       }
 
-      if (tree_obj.crudMode === "D") {
-        _ds.set_mode = "D";
+      if (tree_obj.crudMode === 'D') {
+        _ds.set_mode = 'D';
         // _raw_data_rows = get_data_from_data_feed(); // _ds.raw_data?.rows || [];
         _raw_data_rows = _ds?.v.raw_data?.rows || [];
       }
 
       // initiated with Update but no rows found
-      if (
-        tree_obj.crudMode === "U" &&
-        tree_obj.allowCreate &&
-        !_ds?.data_feed?.rows?.length
-      ) {
-        _ds.set_mode = "C";
+      if (tree_obj.crudMode === 'U' && tree_obj.allowCreate && !_ds?.data_feed?.rows?.length) {
+        _ds.set_mode = 'C';
         // _raw_data_rows[glb.newRecord] = [{ _ROWID: "newRecord" }];
 
         try {
-          const row_idx = find_ROWID_idx_from_raw_data_arr("newRecord");
-          _raw_data_rows[row_idx] = [{ id: "newRecord", value: {} }];
+          const row_idx = find_ROWID_idx_from_raw_data_arr('newRecord');
+          _raw_data_rows[row_idx] = [{ id: 'newRecord', value: {} }];
         } catch (error) {
-          _raw_data_rows.push({ _ROWID: "newRecord" });
+          _raw_data_rows.push({ _ROWID: 'newRecord' });
         }
       }
 
-      if (tree_obj.crudMode === "C") {
-        _ds.set_mode = "C";
+      if (tree_obj.crudMode === 'C') {
+        _ds.set_mode = 'C';
         // _raw_data_rows[glb.newRecord] = [{ _ROWID: "newRecord" }];
         try {
-          const row_idx = find_ROWID_idx_from_raw_data_arr("newRecord");
-          _raw_data_rows[row_idx] = [{ id: "newRecord", value: {} }];
+          const row_idx = find_ROWID_idx_from_raw_data_arr('newRecord');
+          _raw_data_rows[row_idx] = [{ id: 'newRecord', value: {} }];
         } catch (error) {
-          _raw_data_rows.push({ id: "newRecord", value: {} });
+          _raw_data_rows.push({ id: 'newRecord', value: {} });
         }
       }
 
       for await (let raw_data_row of _raw_data_rows) {
         _ds.currentRecordId = raw_data_row.id;
         if (await get_before_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "before_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'before_record');
         }
 
-        await func.datasource.render_fields_dataset(
-          SESSION_ID,
-          dataSourceSession,
-          raw_data_row
-        );
+        await func.datasource.render_fields_dataset(SESSION_ID, dataSourceSession, raw_data_row);
         let data_feed_str = JSON.stringify(_ds.data_feed);
 
         if (await get_after_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "after_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'after_record');
         }
 
-        if (
-          _ds.set_mode === "C" ||
-          JSON.stringify(_ds.data_feed) !== data_feed_str
-        ) {
+        if (_ds.set_mode === 'C' || JSON.stringify(_ds.data_feed) !== data_feed_str) {
           const dbMsgP = await func.db.save_data(SESSION_ID, dataSourceSession);
           if (dbMsgP) _ds.currentRecordId = dbMsgP.id;
-          _ds.set_mode = "U";
+          _ds.set_mode = 'U';
         }
 
-        if (_ds.set_mode === "D") {
+        if (_ds.set_mode === 'D') {
           const dbMsgP = await func.db.save_data(SESSION_ID, dataSourceSession);
           if (dbMsgP) _ds.currentRecordId = dbMsgP.id;
         }
@@ -4541,7 +4244,7 @@ func.datasource.execute = async function (
       await func.datasource.set_outputField(SESSION_ID, dataSourceSession, _ds?.v?.raw_data?.rows, _ds.args);
       break;
 
-    case "component":
+    case 'component':
       _raw_data_rows = _ds?.v.raw_data?.rows || [];
       _ds.rows_processed = 0;
       _ds.viewRangeExp_rows_deleted = 0;
@@ -4552,49 +4255,29 @@ func.datasource.execute = async function (
       _ds.data_feed.rows_deleted = [];
       _ds.data_feed.rows_added = [];
 
-      if (tree_obj.rwMode === "U") {
-        _ds.set_mode = "U";
+      if (tree_obj.rwMode === 'U') {
+        _ds.set_mode = 'U';
       } else {
-        _ds.set_mode = "R";
+        _ds.set_mode = 'R';
       }
 
       const row_not_found = async function () {
-        if (
-          !prog_obj.progDataSource?.dataSourceType ||
-          (tree_obj.rwMode === "U" && tree_obj.allowCreate)
-        ) {
-          _ds.currentRecordId = "newRecord";
-          _ds.set_mode = "C";
+        if (!prog_obj.progDataSource?.dataSourceType || (tree_obj.rwMode === 'U' && tree_obj.allowCreate)) {
+          _ds.currentRecordId = 'newRecord';
+          _ds.set_mode = 'C';
           _ds.record_not_found = true;
 
           try {
-            const row_idx = func.common.find_ROWID_idx(
-              _ds,
-              _ds.currentRecordId
-            );
+            const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
           } catch (error) {
-            await func.datasource.render_fields_form(
-              SESSION_ID,
-              dataSourceSession,
-              { id: "newRecord", value: {} }
-            );
+            await func.datasource.render_fields_form(SESSION_ID, dataSourceSession, { id: 'newRecord', value: {} });
           }
 
-          var count = await func.datasource.get_field_init_count(
-            SESSION_ID,
-            dataSourceSession,
-            "newRecord",
-            false
-          );
+          var count = await func.datasource.get_field_init_count(SESSION_ID, dataSourceSession, 'newRecord', false);
           if (
             count > 0 // was: &&  !args.dataSourceNoP
           ) {
-            await func.datasource.execute_field_init_events(
-              SESSION_ID,
-              dataSourceSession,
-              "form",
-              "newRecord"
-            );
+            await func.datasource.execute_field_init_events(SESSION_ID, dataSourceSession, 'form', 'newRecord');
           }
         }
       };
@@ -4609,20 +4292,13 @@ func.datasource.execute = async function (
         // check if locatedRecordId exist in SESSION_OBJ[SESSION_ID].DS_GLB
         if (_ds.locatedRecordId) {
           try {
-            const row_idx = func.common.find_ROWID_idx(
-              _ds,
-              _ds.locatedRecordId
-            );
+            const row_idx = func.common.find_ROWID_idx(_ds, _ds.locatedRecordId);
           } catch (error) {
             delete _ds.locatedRecordId;
           }
         }
 
-        _ds.finalRecordId = func.datasource.get_currentRecordId(
-          SESSION_ID,
-          dataSourceSession,
-          true
-        );
+        _ds.finalRecordId = func.datasource.get_currentRecordId(SESSION_ID, dataSourceSession, true);
         _ds.currentRecordId = _ds.finalRecordId;
       };
 
@@ -4630,11 +4306,7 @@ func.datasource.execute = async function (
         const idx = Number(key);
 
         if (await get_before_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "before_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'before_record');
         }
 
         // await func.datasource.run_rows_form(
@@ -4648,28 +4320,13 @@ func.datasource.execute = async function (
 
         _ds.currentRecordId = raw_data_row.id; // set temporary to allow expression decoder work
 
-        await func.datasource.render_fields_form(
-          SESSION_ID,
-          dataSourceSession,
-          raw_data_row
-        );
+        await func.datasource.render_fields_form(SESSION_ID, dataSourceSession, raw_data_row);
 
         try {
-          const init_count = await func.datasource.get_field_init_count(
-            SESSION_ID,
-            dataSourceSession,
-            raw_data_row.id,
-            false,
-            _ds.oninit_triggers_to_run
-          );
+          const init_count = await func.datasource.get_field_init_count(SESSION_ID, dataSourceSession, raw_data_row.id, false, _ds.oninit_triggers_to_run);
 
           if (init_count > 0) {
-            await func.datasource.execute_field_init_events(
-              SESSION_ID,
-              dataSourceSession,
-              "form",
-              raw_data_row.id
-            );
+            await func.datasource.execute_field_init_events(SESSION_ID, dataSourceSession, 'form', raw_data_row.id);
           }
         } catch (err) {
           console.error(err);
@@ -4678,11 +4335,7 @@ func.datasource.execute = async function (
         /////////////////////
 
         if (await get_after_record_count()) {
-          await func.datasource.execute_view_events(
-            SESSION_ID,
-            dataSourceSession,
-            "after_record"
-          );
+          await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'after_record');
         }
       }
       await finish_form();
@@ -4690,82 +4343,42 @@ func.datasource.execute = async function (
       break;
 
     default:
-      return func.utils.debug_report(
-        SESSION_ID,
-        "Data source",
-        "Program type not defined",
-        "E"
-      );
+      return func.utils.debug_report(SESSION_ID, 'Data source', 'Program type not defined', 'E');
   }
 
   ret = await callback_datasource();
   return ret;
 };
 
-func.datasource.render_fields_dataset = async function (
-  SESSION_ID,
-  dataSourceSession,
-  raw_data_row
-) {
+func.datasource.render_fields_dataset = async function (SESSION_ID, dataSourceSession, raw_data_row) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   var args = _ds.args;
 
-  const _progFields = await func.datasource.get_progFields(
-    SESSION_ID,
-    dataSourceSession
-  );
+  const _progFields = await func.datasource.get_progFields(SESSION_ID, dataSourceSession);
 
   if (!_progFields) {
     return;
   }
 
   const get_value = async (field_id, value) => {
-    let view_field_obj = func.common.find_item_by_key(
-      _progFields,
-      "field_id",
-      field_id
-    );
+    let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
     var fieldType = view_field_obj?.props?.fieldType;
     let table_field_obj;
-    if (view_field_obj.data.type === "table" && field_id !== "REDUCE_VALUE") {
+    if (view_field_obj.data.type === 'table' && field_id !== 'REDUCE_VALUE') {
       if (!_ds.progDataSource?.dataSourceTableId) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Datasource",
-          `Table type defined without dataSourceTableId deceleration`,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Datasource', `Table type defined without dataSourceTableId deceleration`, 'E');
       }
 
-      let table_obj = await func.utils.FILES_OBJ.get(
-        SESSION_ID,
-        _ds._dataSourceTableId
-      );
+      let table_obj = await func.utils.FILES_OBJ.get(SESSION_ID, _ds._dataSourceTableId);
 
       if (!table_obj) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Datasource",
-          `dataSourceTableId reference error: ` + _ds._dataSourceTableId,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Datasource', `dataSourceTableId reference error: ` + _ds._dataSourceTableId, 'E');
       }
-      table_field_obj = func.common.find_item_by_key(
-        table_obj.tableFields,
-        "field_id",
-        field_id
-      );
+      table_field_obj = func.common.find_item_by_key(table_obj.tableFields, 'field_id', field_id);
       fieldType = table_field_obj.props?.fieldType;
     }
 
-    return await func.common.get_cast_val(
-      SESSION_ID,
-      `render fields dataset ${_ds.viewSourceDesc}`,
-      field_id,
-      fieldType,
-      value,
-      null
-    );
+    return await func.common.get_cast_val(SESSION_ID, `render fields dataset ${_ds.viewSourceDesc}`, field_id, fieldType, value, null);
   };
 
   if (!_ds.data_feed) {
@@ -4786,64 +4399,38 @@ func.datasource.render_fields_dataset = async function (
     try {
       var fieldId = val.data.field_id;
 
-      if (val.data.type === "virtual" || _ds.set_mode === "C") {
-        if (typeof raw_data_row?.value?.[fieldId] !== "undefined") {
+      if (val.data.type === 'virtual' || _ds.set_mode === 'C') {
+        if (typeof raw_data_row?.value?.[fieldId] !== 'undefined') {
           // supports x=x+1
-          _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-            fieldId,
-            raw_data_row.value[fieldId]
-          );
+          _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, raw_data_row.value[fieldId]);
           continue;
         }
 
         if (val.props?.propExpressions?.fieldValue) {
-          let ret = await func.expression.get(
-            SESSION_ID,
-            val.props?.propExpressions?.fieldValue,
-            dataSourceSession,
-            "update",
-            args.rowIdP
-          );
-          _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-            fieldId,
-            ret.result
-          );
+          let ret = await func.expression.get(SESSION_ID, val.props?.propExpressions?.fieldValue, dataSourceSession, 'update', args.rowIdP);
+          _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, ret.result);
           continue;
         }
 
-        _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-          fieldId,
-          val.props?.fieldValue
-        );
+        _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, val.props?.fieldValue);
         continue;
       }
-      if (val.data.type === "table" || val.data.type === "datasource") {
-        if (typeof raw_data_row.value[fieldId] === "undefined") {
-          throw "field do not exist in data: " + fieldId;
+      if (val.data.type === 'table' || val.data.type === 'datasource') {
+        if (typeof raw_data_row.value[fieldId] === 'undefined') {
+          throw 'field do not exist in data: ' + fieldId;
         }
-        _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-          fieldId,
-          raw_data_row.value[fieldId]
-        );
+        _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, raw_data_row.value[fieldId]);
       }
     } catch (err) {
-      func.utils.debug_report(SESSION_ID, "Datasource", err, "E", null, _ds);
+      func.utils.debug_report(SESSION_ID, 'Datasource', err, 'E', null, _ds);
     }
   }
 };
 
-func.datasource.run_events_functions = async function (
-  SESSION_ID,
-  dataSourceSession,
-  event_id,
-  calling_job,
-  async_event,
-  event_parameters
-) {
-
-  if (typeof dataSourceSession === "undefined" || dataSourceSession === null) {
-    console.warn(`Event ${event_id} not exist or not found`)
-    return
+func.datasource.run_events_functions = async function (SESSION_ID, dataSourceSession, event_id, calling_job, async_event, event_parameters) {
+  if (typeof dataSourceSession === 'undefined' || dataSourceSession === null) {
+    console.warn(`Event ${event_id} not exist or not found`);
+    return;
   }
 
   // return new Promise(async (resolve, reject) => {
@@ -4851,123 +4438,75 @@ func.datasource.run_events_functions = async function (
   var args = _ds.args;
   // var v = _ds.v;
   const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
-  let job_promises = []
+  let job_promises = [];
   if (_view_obj.progEvents) {
     for await (const [key, val] of Object.entries(_view_obj.progEvents)) {
-      if (
-        val.data.type === "user_defined" &&
-        val.data.event_name &&
-        val.data.event_name === event_id
-      ) {
+      if (val.data.type === 'user_defined' && val.data.event_name && val.data.event_name === event_id) {
         const jobs = await func.events.validate(
           SESSION_ID,
-          "user_defined",
+          'user_defined',
           dataSourceSession,
           val.data.event_name,
           args.callingSourceP,
-          event_parameters// val.data.parameters
+          event_parameters, // val.data.parameters
         );
 
-        if (calling_job || async_event) continue
+        if (calling_job || async_event) continue;
 
         for (let job_num of jobs) {
-          job_promises.push(new Promise((resolve, reject) => {
-
-            const interval = setInterval(() => {
-              var job_index = func.events.find_job_index(SESSION_ID, job_num);
-              if (job_index == null) {
-                clearInterval(interval)
-                resolve(job_num);
-              }
-            }, 100);
-          }))
+          job_promises.push(
+            new Promise((resolve, reject) => {
+              const interval = setInterval(() => {
+                var job_index = func.events.find_job_index(SESSION_ID, job_num);
+                if (job_index == null) {
+                  clearInterval(interval);
+                  resolve(job_num);
+                }
+              }, 100);
+            }),
+          );
         }
       }
     }
-
-
-
   }
   if (job_promises.length) {
-    await Promise.all(job_promises)
+    await Promise.all(job_promises);
   }
-
-
 };
 
-func.datasource.render_fields_form = async function (
-  SESSION_ID,
-  dataSourceSession,
-  raw_data_row
-) {
+func.datasource.render_fields_form = async function (SESSION_ID, dataSourceSession, raw_data_row) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
 
-  const _progFields = await func.datasource.get_progFields(
-    SESSION_ID,
-    dataSourceSession
-  );
+  const _progFields = await func.datasource.get_progFields(SESSION_ID, dataSourceSession);
 
   if (!_progFields) {
     return;
   }
 
   const get_value = async (field_id, value) => {
-    let view_field_obj = func.common.find_item_by_key(
-      _progFields,
-      "field_id",
-      field_id
-    );
+    let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
     var fieldType = view_field_obj.props?.fieldType;
     let table_field_obj;
-    if (view_field_obj.data.type === "table" && field_id !== "REDUCE_VALUE") {
+    if (view_field_obj.data.type === 'table' && field_id !== 'REDUCE_VALUE') {
       if (!_ds._dataSourceTableId) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Datasource",
-          `Table type defined without dataSourceTableId deceleration`,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Datasource', `Table type defined without dataSourceTableId deceleration`, 'E');
       }
 
-      let table_obj = await func.utils.FILES_OBJ.get(
-        SESSION_ID,
-        _ds._dataSourceTableId
-      );
+      let table_obj = await func.utils.FILES_OBJ.get(SESSION_ID, _ds._dataSourceTableId);
 
       if (!table_obj) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Datasource",
-          `dataSourceTableId reference error: ` + _ds._dataSourceTableId,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Datasource', `dataSourceTableId reference error: ` + _ds._dataSourceTableId, 'E');
       }
-      table_field_obj = func.common.find_item_by_key(
-        table_obj.tableFields,
-        "field_id",
-        field_id
-      );
+      table_field_obj = func.common.find_item_by_key(table_obj.tableFields, 'field_id', field_id);
 
       if (!table_field_obj) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Datasource",
-          `Field Id: ${field_id} not exist in table ${table_obj.properties.menuName}`,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Datasource', `Field Id: ${field_id} not exist in table ${table_obj.properties.menuName}`, 'E');
       }
 
       fieldType = table_field_obj.props?.fieldType;
     }
 
-    return await func.common.get_cast_val(
-      SESSION_ID,
-      `render fields datasource ${_ds.viewSourceDesc}`,
-      field_id,
-      fieldType,
-      value,
-      null
-    );
+    return await func.common.get_cast_val(SESSION_ID, `render fields datasource ${_ds.viewSourceDesc}`, field_id, fieldType, value, null);
   };
 
   let row_idx;
@@ -4984,29 +4523,20 @@ func.datasource.render_fields_form = async function (
     try {
       var fieldId = val.data.field_id;
 
-      if (val.data.type === "virtual" || raw_data_row.id === "newRecord") {
+      if (val.data.type === 'virtual' || raw_data_row.id === 'newRecord') {
         if (glb.PROTECTED_VARS.includes(fieldId)) {
           switch (fieldId) {
-            case "_ROWNO": {
-              _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-                fieldId,
-                row_idx
-              );
+            case '_ROWNO': {
+              _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, row_idx);
               continue;
             }
-            case "_ROWID": {
-              _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-                fieldId,
-                raw_data_row.id
-              );
+            case '_ROWID': {
+              _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, raw_data_row.id);
 
               continue;
             }
-            case "_ROWDOC": {
-              _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-                fieldId,
-                raw_data_row.value
-              );
+            case '_ROWDOC': {
+              _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, raw_data_row.value);
 
               continue;
             }
@@ -5015,39 +4545,24 @@ func.datasource.render_fields_form = async function (
 
         if (val.props?.propExpressions?.fieldValue) {
           // check init exp existence
-          let ret = await func.expression.get(
-            SESSION_ID,
-            val.props?.propExpressions?.fieldValue,
-            dataSourceSession,
-            "update",
-            raw_data_row.id
-          );
-          _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-            fieldId,
-            ret.result
-          );
+          let ret = await func.expression.get(SESSION_ID, val.props?.propExpressions?.fieldValue, dataSourceSession, 'update', raw_data_row.id);
+          _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, ret.result);
 
           continue;
         }
 
-        _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-          fieldId,
-          val.props?.fieldValue
-        );
+        _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, val.props?.fieldValue);
 
         continue;
       }
-      if (val.data.type === "table" || val.data.type === "datasource") {
-        if (typeof raw_data_row.value[fieldId] === "undefined") {
-          throw "field do not exist in data: " + fieldId;
+      if (val.data.type === 'table' || val.data.type === 'datasource') {
+        if (typeof raw_data_row.value[fieldId] === 'undefined') {
+          throw 'field do not exist in data: ' + fieldId;
         }
-        _ds.data_feed.rows[row_idx][fieldId] = await get_value(
-          fieldId,
-          raw_data_row.value[fieldId]
-        );
+        _ds.data_feed.rows[row_idx][fieldId] = await get_value(fieldId, raw_data_row.value[fieldId]);
       }
     } catch (err) {
-      func.utils.debug_report(SESSION_ID, "Datasource", err, "E", null, _ds);
+      func.utils.debug_report(SESSION_ID, 'Datasource', err, 'E', null, _ds);
     }
   }
 };
@@ -5110,12 +4625,7 @@ func.datasource.render_fields_form = async function (
 //   // await form_continue();
 // };
 
-func.datasource.execute_field_init_events = async function (
-  SESSION_ID,
-  dataSourceSession,
-  sourceP,
-  rowIdP
-) {
+func.datasource.execute_field_init_events = async function (SESSION_ID, dataSourceSession, sourceP, rowIdP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   var args = _ds.args;
   var arr = _ds.dataSource_init_arr[rowIdP];
@@ -5125,21 +4635,11 @@ func.datasource.execute_field_init_events = async function (
     if (!func.utils.is_onscreen_event(val.eventInfo.data.action)) {
       var cond = val?.eventInfo?.data?.enabled;
       var expression = undefined;
-      if (val.eventInfo.props.condition)
-        expression = val.eventInfo.props.condition;
+      if (val.eventInfo.props.condition) expression = val.eventInfo.props.condition;
       var expCond = {};
       if (expression && !_.isEmpty(expression)) {
         // check if expression exist
-        expCond = await func.expression.get(
-          SESSION_ID,
-          expression,
-          dataSourceSession,
-          "condition",
-          rowIdP,
-          null,
-          null,
-          val.fieldId
-        ); // execute expression
+        expCond = await func.expression.get(SESSION_ID, expression, dataSourceSession, 'condition', rowIdP, null, null, val.fieldId); // execute expression
         cond = expCond.result;
         expCond.conditional = true;
         val.DEBUG_INFO_OBJ.result = expCond.result;
@@ -5181,20 +4681,14 @@ func.datasource.execute_field_init_events = async function (
           null,
           null,
           null,
-          ds.parentDataSourceNo
+          ds.parentDataSourceNo,
         );
       }
     }
   }
 };
 
-func.datasource.get_field_init_count = async function (
-  SESSION_ID,
-  dataSourceSession,
-  rowIdP,
-  pre_initP,
-  oninit_triggers_to_runP
-) {
+func.datasource.get_field_init_count = async function (SESSION_ID, dataSourceSession, rowIdP, pre_initP, oninit_triggers_to_runP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   var args = _ds.args;
 
@@ -5210,25 +4704,15 @@ func.datasource.get_field_init_count = async function (
       continue;
     }
     for await (const trigger_obj of field_obj.triggers) {
-      if (
-        oninit_triggers_to_runP &&
-        !oninit_triggers_to_runP?.includes(trigger_obj.id)
-      ) {
+      if (oninit_triggers_to_runP && !oninit_triggers_to_runP?.includes(trigger_obj.id)) {
         continue;
       }
       if (
         // trigger_obj.data.trigger === "oninit" &&
-        ["get_data", "set_data", "batch", "update", "raise_event"].includes(
-          trigger_obj.data.action
-        )
+        ['get_data', 'set_data', 'batch', 'update', 'raise_event'].includes(trigger_obj.data.action)
       ) {
         if (!trigger_obj.data.action) {
-          func.utils.debug_report(
-            SESSION_ID,
-            "_ds.get_field_init_count",
-            `Error initiating event for field: ${fieldId} prog: ${_ds.v.viewSourceDesc} row: ${rowIdP} reason: missing action`,
-            "E"
-          );
+          func.utils.debug_report(SESSION_ID, '_ds.get_field_init_count', `Error initiating event for field: ${fieldId} prog: ${_ds.v.viewSourceDesc} row: ${rowIdP} reason: missing action`, 'E');
           break;
         }
 
@@ -5262,14 +4746,14 @@ func.datasource.get_field_init_count = async function (
             fieldId: fieldId,
             rowId: rowIdP,
             colId: field_obj.id,
-            node_id: args.prog_id + "_" + trigger_obj.id + "_" + field_obj.id,
+            node_id: args.prog_id + '_' + trigger_obj.id + '_' + field_obj.id,
             fieldProp: field_obj,
             DEBUG_INFO_OBJ: {
               module: _ds.viewModule,
-              action: "init field event",
+              action: 'init field event',
               prop: fieldId,
               source: _ds.viewSourceDesc,
-              type: "event",
+              type: 'event',
               prog_id: args.prog_id,
               dsSession: dataSourceSession,
             },
@@ -5283,19 +4767,14 @@ func.datasource.get_field_init_count = async function (
   return ret;
 };
 
-func.datasource.get_view_events_count = async function (
-  SESSION_ID,
-  dataSourceSession,
-  typeP,
-  eventIdP
-) {
+func.datasource.get_view_events_count = async function (SESSION_ID, dataSourceSession, typeP, eventIdP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   const _prog = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
   if (!_ds) return 0;
   var args = _ds.args;
 
   var index = typeP;
-  if (eventIdP) index = typeP + "_" + eventIdP;
+  if (eventIdP) index = typeP + '_' + eventIdP;
 
   // client interval
   if (!_ds.viewEventExec_arr) _ds.viewEventExec_arr = {};
@@ -5309,18 +4788,7 @@ func.datasource.get_view_events_count = async function (
     if (eventIdP && event_obj.id !== eventIdP) continue; // match w ID added 03312017
 
     if (event_obj.data.condition) {
-      let res = await func.expression.get(
-        SESSION_ID,
-        event_obj.data.condition,
-        dataSourceSession,
-        "condition",
-        args.rowIdP,
-        null,
-        null,
-        null,
-        null,
-        event_obj
-      );
+      let res = await func.expression.get(SESSION_ID, event_obj.data.condition, dataSourceSession, 'condition', args.rowIdP, null, null, null, null, event_obj);
       if (!res.result) {
         continue;
       }
@@ -5330,13 +4798,12 @@ func.datasource.get_view_events_count = async function (
     for (const trigger_obj of event_obj.triggers) {
       if (trigger_obj.data.enabled) {
         var expression;
-        if (trigger_obj.props.condition)
-          expression = trigger_obj.props.condition;
+        if (trigger_obj.props.condition) expression = trigger_obj.props.condition;
         var expCond = {};
         if (expression) {
           expCond.conditional = true;
         }
-        func.utils.debug.log(SESSION_ID, args.prog_id + "_" + trigger_obj.id, {
+        func.utils.debug.log(SESSION_ID, args.prog_id + '_' + trigger_obj.id, {
           module: _ds.viewModule,
           action: trigger_obj.data.action,
           prop: event_obj.data.type,
@@ -5345,31 +4812,18 @@ func.datasource.get_view_events_count = async function (
           error: expCond.error,
           source: _ds.viewSourceDesc,
           fields: expCond.fields,
-          type: "event",
+          type: 'event',
           prog_id: args.prog_id,
           dsSession: dataSourceSession,
           conditional: expCond.conditional,
         });
-      }
-      if (!trigger_obj.data.action) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "get_view_events_count",
-          `Error initiating ${typeP} prog:${_ds.v.viewSourceDesc} reason: missing action`,
-          "E"
-        );
-        break;
-      }
-      if (
-        !glb.REFERENCE_LESS_FUNCTIONS.includes(trigger_obj.data.action) &&
-        !trigger_obj.data.action
-      ) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "get_view_events_count",
-          `Error initiating ${typeP} prog: ${_ds.v.viewSourceDesc} reason: missing reference`,
-          "E"
-        );
+      }
+      if (!trigger_obj.data.action) {
+        func.utils.debug_report(SESSION_ID, 'get_view_events_count', `Error initiating ${typeP} prog:${_ds.v.viewSourceDesc} reason: missing action`, 'E');
+        break;
+      }
+      if (!glb.REFERENCE_LESS_FUNCTIONS.includes(trigger_obj.data.action) && !trigger_obj.data.action) {
+        func.utils.debug_report(SESSION_ID, 'get_view_events_count', `Error initiating ${typeP} prog: ${_ds.v.viewSourceDesc} reason: missing reference`, 'E');
         break;
       }
       if (trigger_obj.data.enabled) {
@@ -5385,50 +4839,28 @@ func.datasource.get_view_events_count = async function (
   }
   return _ds.viewEventExec_arr[index].length;
 };
-func.datasource.execute_view_events = async function (
-  SESSION_ID,
-  dataSourceSession,
-  typeP,
-  eventIdP
-) {
+func.datasource.execute_view_events = async function (SESSION_ID, dataSourceSession, typeP, eventIdP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   var args = _ds.args;
 
   var i = -1;
   var index = typeP;
-  if (eventIdP) index = typeP + "_" + eventIdP;
+  if (eventIdP) index = typeP + '_' + eventIdP;
   var arr = _ds.viewEventExec_arr[index];
   if (_.isEmpty(arr)) return;
 
   for await (const val of arr) {
-    if (
-      !glb.IS_WORKER ||
-      !func.utils.is_onscreen_event(val.eventInfo.data.action) ||
-      (glb.IS_WORKER &&
-        _ds.v.run_at === "server" &&
-        !func.utils.is_onscreen_event(val.eventInfo.data.action))
-    ) {
+    if (!glb.IS_WORKER || !func.utils.is_onscreen_event(val.eventInfo.data.action) || (glb.IS_WORKER && _ds.v.run_at === 'server' && !func.utils.is_onscreen_event(val.eventInfo.data.action))) {
       // val.done = true;
       var cond = true;
       if (val.expression) {
-        var expCond = await func.expression.get(
-          SESSION_ID,
-          val.expression,
-          dataSourceSession,
-          "condition",
-          args.rowIdP,
-          null,
-          null,
-          null,
-          null,
-          val.eventInfo
-        ); // execute expression
+        var expCond = await func.expression.get(SESSION_ID, val.expression, dataSourceSession, 'condition', args.rowIdP, null, null, null, null, val.eventInfo); // execute expression
         cond = expCond.result;
       }
       if (cond) {
         var elem_params = undefined;
         if (!glb.IS_WORKER) {
-          elem_params = $("#" + _ds.containerId).data("params");
+          elem_params = $('#' + _ds.containerId).data('params');
         }
         const ret = await func.events.execute(
           SESSION_ID,
@@ -5445,39 +4877,28 @@ func.datasource.execute_view_events = async function (
           null,
           dataSourceSession,
           val.eventId,
-          _ds.tree_obj.menuType + " event",
+          _ds.tree_obj.menuType + ' event',
           true,
           null,
           null,
           args.jobNoP,
           elem_params,
           null,
-          val.eventInfo
+          val.eventInfo,
         );
       }
 
       continue;
     }
     // on screen event
-    if (
-      typeP == "before_record" ||
-      typeP == "after_record" ||
-      typeP == "on_load" ||
-      typeP == "on_exit"
-    ) {
+    if (typeP == 'before_record' || typeP == 'after_record' || typeP == 'on_load' || typeP == 'on_exit') {
       _ds.v.onscreen_events_active = {
         i: i,
         type: typeP,
       };
-      var parent_ds_chain = func.datasource.get_parent_ds_chain(
-        SESSION_ID,
-        dataSourceSession
-      );
+      var parent_ds_chain = func.datasource.get_parent_ds_chain(SESSION_ID, dataSourceSession);
       var obj = {
-        ds_obj: func.utils.clean_returned_datasource(
-          SESSION_ID,
-          dataSourceSession
-        ),
+        ds_obj: func.utils.clean_returned_datasource(SESSION_ID, dataSourceSession),
         dsSessionP: dataSourceSession,
       };
       obj.ds_obj.parent_ds_chain = parent_ds_chain;
@@ -5488,10 +4909,7 @@ func.datasource.get_parent_ds_chain = function (SESSION_ID, dataSourceSession) {
   var arr = [];
   var drill = function (ds) {
     if (SESSION_OBJ[SESSION_ID].DS_GLB[ds]) {
-      if (
-        typeof SESSION_OBJ[SESSION_ID].DS_GLB[ds].parentDataSourceNo !==
-        "undefined"
-      ) {
+      if (typeof SESSION_OBJ[SESSION_ID].DS_GLB[ds].parentDataSourceNo !== 'undefined') {
         arr.push(SESSION_OBJ[SESSION_ID].DS_GLB[ds].parentDataSourceNo);
         drill(SESSION_OBJ[SESSION_ID].DS_GLB[ds].parentDataSourceNo);
       }
@@ -5500,11 +4918,7 @@ func.datasource.get_parent_ds_chain = function (SESSION_ID, dataSourceSession) {
   drill(dataSourceSession);
   return arr;
 };
-func.datasource.execute_onscreen_view_events = async function (
-  SESSION_ID,
-  dataSourceSession,
-  sourceP
-) {
+func.datasource.execute_onscreen_view_events = async function (SESSION_ID, dataSourceSession, sourceP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   var args = _ds.args;
 
@@ -5517,13 +4931,7 @@ func.datasource.execute_onscreen_view_events = async function (
 
     var cond = true;
     if (evnt.expression) {
-      var expCond = await func.expression.get(
-        SESSION_ID,
-        evnt.expression,
-        dataSourceSession,
-        "condition",
-        args.rowIdP
-      ); // execute expression
+      var expCond = await func.expression.get(SESSION_ID, evnt.expression, dataSourceSession, 'condition', args.rowIdP); // execute expression
       cond = expCond.result;
     }
     if (cond) {
@@ -5542,20 +4950,16 @@ func.datasource.execute_onscreen_view_events = async function (
         null,
         dataSourceSession,
         null,
-        sourceP + " event",
+        sourceP + ' event',
         true,
         null,
         null,
-        args.jobNoP
+        args.jobNoP,
       );
     }
-  } else console.error("*execute_onscreen_view_events error");
+  } else console.error('*execute_onscreen_view_events error');
 };
-func.datasource.get_event_interval_arr = function (
-  SESSION_ID,
-  dataSourceSession,
-  typeP
-) {
+func.datasource.get_event_interval_arr = function (SESSION_ID, dataSourceSession, typeP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   // var v = _ds.v;
   var arr = [];
@@ -5596,19 +5000,17 @@ func.datasource.clean = function (SESSION_ID, screenIdP) {
         Number(key) > 0 &&
         (val.screenId === screenIdP ||
           val.rootScreenId === screenIdP ||
-          $("#" + val.screenId)
+          $('#' + val.screenId)
             .parent()
-            .attr("id") === screenIdP ||
-          (val &&
-            val.parentDataSourceNo &&
-            arr.includes(val.parentDataSourceNo.toString())))
+            .attr('id') === screenIdP ||
+          (val && val.parentDataSourceNo && arr.includes(val.parentDataSourceNo.toString())))
       ) {
         arr.push(key);
         if (val.screenId) func.UI.utils.screen_blocker(false, val.screenId);
       }
     } catch (err) {
-      console.warn("func.datasource.clean failed");
-      func.datasource.reset_jobs(SESSION_ID, key, "datasource.clean", err);
+      console.warn('func.datasource.clean failed');
+      func.datasource.reset_jobs(SESSION_ID, key, 'datasource.clean', err);
     }
   }
   for (let val of arr) {
@@ -5616,27 +5018,19 @@ func.datasource.clean = function (SESSION_ID, screenIdP) {
   }
 };
 func.datasource.del = function (SESSION_ID, dsP) {
-  if (
-    (SESSION_OBJ[SESSION_ID].DS_GLB[dsP] &&
-      SESSION_OBJ[SESSION_ID].DS_GLB[dsP].keep_alive) ||
-    dsP == 0
-  )
-    return;
-  if (
-    DATASOURCE_INTERVALS[SESSION_ID] &&
-    DATASOURCE_INTERVALS[SESSION_ID][dsP]
-  ) {
+  if ((SESSION_OBJ[SESSION_ID].DS_GLB[dsP] && SESSION_OBJ[SESSION_ID].DS_GLB[dsP].keep_alive) || dsP == 0) return;
+  if (DATASOURCE_INTERVALS[SESSION_ID] && DATASOURCE_INTERVALS[SESSION_ID][dsP]) {
     DATASOURCE_INTERVALS[SESSION_ID][dsP].clear();
   }
 
   const perform_delete = async function () {
     var response = {
-      success: function (jsonP, ajaxP) { },
+      success: function (jsonP, ajaxP) {},
       error: function (status) {
-        console.error("error datasource:" + status);
+        console.error('error datasource:' + status);
       },
       fail: function (status) {
-        console.error("error datasource:" + status);
+        console.error('error datasource:' + status);
       },
     };
 
@@ -5650,14 +5044,9 @@ func.datasource.del = function (SESSION_ID, dsP) {
       let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsP];
       if (_ds.worker_id) {
         // if (_ds.data_xuda) console.log(dsP);
-        if (
-          RUNTIME_SERVER_WEBSOCKET &&
-          RUNTIME_SERVER_WEBSOCKET_CONNECTED &&
-          (!_session.opt.app_computing_mode ||
-            _session.opt.app_computing_mode === "server")
-        ) {
-          WEB_WORKER[SESSION_ID][_ds.worker_id].emit("message", {
-            service: "close_websocket",
+        if (RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED && (!_session.opt.app_computing_mode || _session.opt.app_computing_mode === 'server')) {
+          WEB_WORKER[SESSION_ID][_ds.worker_id].emit('message', {
+            service: 'close_websocket',
           });
         } else {
           WEB_WORKER[SESSION_ID][_ds.worker_id].worker.terminate();
@@ -5666,7 +5055,7 @@ func.datasource.del = function (SESSION_ID, dsP) {
         delete WEB_WORKER[SESSION_ID][_ds.worker_id];
       } else {
         const json = await func.index.call_worker(SESSION_ID, {
-          service: "datasource_delete",
+          service: 'datasource_delete',
           data: data,
           id: _ds.worker_id,
         });
@@ -5682,7 +5071,7 @@ func.datasource.del = function (SESSION_ID, dsP) {
     _.forEach(SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs, function (val, key) {
       if (val && val.dsSessionP == dsP) {
         arr.push(key);
-        for (const [key, val] of Object.entries($(".screen_blocker"))) {
+        for (const [key, val] of Object.entries($('.screen_blocker'))) {
           $(val).remove();
         }
       }
@@ -5690,23 +5079,16 @@ func.datasource.del = function (SESSION_ID, dsP) {
     for (let val of arr.reverse()) {
       SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs.splice(val, 1);
     }
-    if (!SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs.length)
-      SESSION_OBJ[SESSION_ID].WORKER_OBJ.stat = null;
+    if (!SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs.length) SESSION_OBJ[SESSION_ID].WORKER_OBJ.stat = null;
   };
   if (!glb.IS_WORKER) {
     if (SESSION_OBJ[SESSION_ID].DS_GLB[dsP]) {
-      delete SCREEN_BLOCKER_OBJ[
-        SESSION_OBJ[SESSION_ID].DS_GLB[dsP].screenId +
-        "_" +
-        SESSION_OBJ[SESSION_ID].DS_GLB[dsP].callingScreenId
-      ];
+      delete SCREEN_BLOCKER_OBJ[SESSION_OBJ[SESSION_ID].DS_GLB[dsP].screenId + '_' + SESSION_OBJ[SESSION_ID].DS_GLB[dsP].callingScreenId];
 
       delete_pending_jobs();
     }
-    if ($(SESSION_OBJ[SESSION_ID].root_element).find("xu-nav").length) {
-      var ds_obj = $(SESSION_OBJ[SESSION_ID].root_element)
-        .find("xu-nav")
-        ?.data()?.xuData.nav_params;
+    if ($(SESSION_OBJ[SESSION_ID].root_element).find('xu-nav').length) {
+      var ds_obj = $(SESSION_OBJ[SESSION_ID].root_element).find('xu-nav')?.data()?.xuData.nav_params;
       if (ds_obj) {
         delete ds_obj[dsP];
       }
@@ -5714,86 +5096,63 @@ func.datasource.del = function (SESSION_ID, dsP) {
   }
   perform_delete();
 };
-func.datasource.update = async function (
-  SESSION_ID,
-  datasource_changes,
-  update_local_scope_only,
-  avoid_refresh
-) {
+func.datasource.update = async function (SESSION_ID, datasource_changes, update_local_scope_only, avoid_refresh) {
   return new Promise(async (resolve, reject) => {
     var _session = SESSION_OBJ[SESSION_ID];
 
-    if (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== "undefined" || typeof IS_PROCESS_SERVER !== "undefined") {
-      update_local_scope_only = true
+    if (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== 'undefined' || typeof IS_PROCESS_SERVER !== 'undefined') {
+      update_local_scope_only = true;
     }
 
-    if (typeof glb.GLOBAL_VARS === "undefined") {
-      glb.GLOBAL_VARS = (
-        await func.common.get_module(
-          SESSION_ID,
-          "xuda-system-globals-module.mjs"
-        )
-      ).system_globals;
+    if (typeof glb.GLOBAL_VARS === 'undefined') {
+      glb.GLOBAL_VARS = (await func.common.get_module(SESSION_ID, 'xuda-system-globals-module.mjs')).system_globals;
     }
 
     const set_fieldComputed_dependencies = async function (dsNo, field_id, parent_ds) {
-
       // iterate child ds
       for (const [dsSession, _ds] of Object.entries(_session.DS_GLB)) {
         if (parent_ds !== null) {
-          if (_ds.parentDataSourceNo != parent_ds) continue
+          if (_ds.parentDataSourceNo != parent_ds) continue;
         } else {
-          if (dsSession != dsNo) continue
+          if (dsSession != dsNo) continue;
         }
         let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
-        if (tree_ret.menuType === "component" || tree_ret.menuType === "globals") {
+        if (tree_ret.menuType === 'component' || tree_ret.menuType === 'globals') {
           // check if field has fieldComputed property
-          const _progFields = await func.datasource.get_progFields(
-            SESSION_ID,
-            dsSession
-          );
+          const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSession);
           // find if field is computed
-          let fieldComputed_propExpressions, fieldComputed_id
+          let fieldComputed_propExpressions, fieldComputed_id;
           for await (const val of _progFields) {
-
             const fieldId = val.data.field_id;
 
             // if (fieldId !== field_id) continue
-            if (val.data.type !== "virtual" || !val.props.fieldComputed) continue
+            if (val.data.type !== 'virtual' || !val.props.fieldComputed) continue;
 
-            const _propExpressions = val.props?.propExpressions?.fieldValue
+            const _propExpressions = val.props?.propExpressions?.fieldValue;
             if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
-              fieldComputed_propExpressions = _propExpressions
-              fieldComputed_id = fieldId
+              fieldComputed_propExpressions = _propExpressions;
+              fieldComputed_id = fieldId;
             }
           }
 
-          if (!fieldComputed_id) return
-
+          if (!fieldComputed_id) return;
 
           // iterate ds rows
           for (const row of _ds.data_feed?.rows || []) {
             // iterate row fields
             for (const [key, val] of Object.entries(row)) {
-              if (key !== fieldComputed_id) continue
+              if (key !== fieldComputed_id) continue;
               try {
-
-                let ret = await func.expression.get(
-                  SESSION_ID,
-                  fieldComputed_propExpressions,
-                  dsNo,
-                  "update",
-                  row._ROWID
-                );
+                let ret = await func.expression.get(SESSION_ID, fieldComputed_propExpressions, dsNo, 'update', row._ROWID);
 
                 const row_idx = func.common.find_ROWID_idx(_ds, row._ROWID);
                 if (_ds.data_feed.rows[row_idx][fieldComputed_id] !== ret.result) {
                   _ds.data_feed.rows[row_idx][fieldComputed_id] = ret.result;
                   if (!fields_changed.includes(fieldComputed_id)) {
-                    fields_changed.push(fieldComputed_id)
+                    fields_changed.push(fieldComputed_id);
                   }
                   if (!datasource_changed.includes(dsSession)) {
-                    datasource_changed.push(dsSession)
+                    datasource_changed.push(dsSession);
                   }
                 }
               } catch (err) {
@@ -5802,19 +5161,16 @@ func.datasource.update = async function (
             }
           }
         }
-        await set_fieldComputed_dependencies(dsNo, field_id, dsSession)
+        await set_fieldComputed_dependencies(dsNo, field_id, dsSession);
       }
-
-    }
+    };
 
     var fields_changed = [];
     var datasource_changed = [];
-    let client_datasource_changes = {}
-    let server_datasource_changes = {}
+    let client_datasource_changes = {};
+    let server_datasource_changes = {};
     // iterate changes datasource
-    for await (const [dataSource, row_data] of Object.entries(
-      datasource_changes
-    )) {
+    for await (const [dataSource, row_data] of Object.entries(datasource_changes)) {
       var _ds = _session.DS_GLB[dataSource];
       if (!_ds) {
         continue;
@@ -5824,12 +5180,12 @@ func.datasource.update = async function (
         // iterate changes fields
         for (const [field_id, value] of Object.entries(fields_data)) {
           // mechanism to make update directly on the datasource object
-          if (record_id === "datasource_main") {
+          if (record_id === 'datasource_main') {
             _.set(_ds, field_id, value);
             continue;
           }
 
-          if (typeof fields_data === "object") {
+          if (typeof fields_data === 'object') {
             if (glb.GLOBAL_VARS[field_id]) {
               _ds.data_system[field_id] = value;
 
@@ -5839,42 +5195,33 @@ func.datasource.update = async function (
             try {
               const row_idx = func.common.find_ROWID_idx(_ds, record_id);
               _ds.data_feed.rows[row_idx][field_id] = value;
-              await set_fieldComputed_dependencies(dataSource, field_id, null)
+              await set_fieldComputed_dependencies(dataSource, field_id, null);
 
               if (!update_local_scope_only) {
                 let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
                 if (glb.IS_WORKER) {
                   // RUN AT SERVER
-                  if (tree_ret.menuType === "globals" || tree_ret.menuType === "component") {
-
-                    const _progFields = await func.datasource.get_progFields(
-                      SESSION_ID,
-                      dataSource
-                    );
-                    let view_field_obj = func.common.find_item_by_key(
-                      _progFields,
-                      "field_id",
-                      field_id
-                    );
-                    if (!view_field_obj?.data?.serverField && record_id !== "data_system") {
+                  if (tree_ret.menuType === 'globals' || tree_ret.menuType === 'component') {
+                    const _progFields = await func.datasource.get_progFields(SESSION_ID, dataSource);
+                    let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
+                    if (!view_field_obj?.data?.serverField && record_id !== 'data_system') {
                       if (!client_datasource_changes[dataSource]) {
-                        client_datasource_changes[dataSource] = {}
+                        client_datasource_changes[dataSource] = {};
                       }
                       if (!client_datasource_changes[dataSource][record_id]) {
-                        client_datasource_changes[dataSource][record_id] = {}
+                        client_datasource_changes[dataSource][record_id] = {};
                       }
                       client_datasource_changes[dataSource][record_id][field_id] = value;
                     }
-
                   }
                 } else {
                   // RUN AT CLIENT
-                  if ((tree_ret.menuType === "component" && _ds._run_at !== "client") || tree_ret.menuType === "globals") {
+                  if ((tree_ret.menuType === 'component' && _ds._run_at !== 'client') || tree_ret.menuType === 'globals') {
                     if (!server_datasource_changes[dataSource]) {
-                      server_datasource_changes[dataSource] = {}
+                      server_datasource_changes[dataSource] = {};
                     }
                     if (!server_datasource_changes[dataSource][record_id]) {
-                      server_datasource_changes[dataSource][record_id] = {}
+                      server_datasource_changes[dataSource][record_id] = {};
                     }
                     server_datasource_changes[dataSource][record_id][field_id] = value;
                   }
@@ -5894,14 +5241,10 @@ func.datasource.update = async function (
             if (!_ds.data_feed.rows_changed) {
               _ds.data_feed.rows_changed = [];
             }
-            if (!_ds.data_feed.rows_changed.includes(record_id))
-              _ds.data_feed.rows_changed.push(record_id);
-
-          } else if (fields_data === "set") {
+            if (!_ds.data_feed.rows_changed.includes(record_id)) _ds.data_feed.rows_changed.push(record_id);
+          } else if (fields_data === 'set') {
             _ds.currentRecordId = record_id;
           }
-
-
         }
         // if (!_ds.data_feed.rows_changed) {
         //   _ds.data_feed.rows_changed = [];
@@ -5909,30 +5252,16 @@ func.datasource.update = async function (
         // if (!_ds.data_feed.rows_changed.includes(record_id))
         //   _ds.data_feed.rows_changed.push(record_id);
       }
-
-
-
-
-
     }
 
     if (glb.IS_WORKER) {
-
       if (!update_local_scope_only && !_.isEmpty(client_datasource_changes)) {
-        func.utils.post_back_to_client(
-          SESSION_ID,
-          "update_client_eventChangesResults_from_worker",
-          _session.worker_id,
-          client_datasource_changes
-        );
-
+        func.utils.post_back_to_client(SESSION_ID, 'update_client_eventChangesResults_from_worker', _session.worker_id, client_datasource_changes);
       }
-
     } else {
       if (!update_local_scope_only && !_.isEmpty(server_datasource_changes)) {
-
         const ret = await func.index.call_worker(SESSION_ID, {
-          service: "update_datasource_changes_from_client",
+          service: 'update_datasource_changes_from_client',
           data: {
             session_id: SESSION_ID,
             datasource_changes: server_datasource_changes,
@@ -5947,16 +5276,14 @@ func.datasource.update = async function (
           SESSION_ID,
           fields_changed,
           null,
-          datasource_changed[0] // refresh the current datasource only
+          datasource_changed[0], // refresh the current datasource only
         );
       }
     }
     resolve();
   });
-
 };
 
-
 // func.datasource.update = async function (
 //   SESSION_ID,
 //   datasource_changes,
@@ -6042,8 +5369,6 @@ func.datasource.update = async function (
 //       }
 //       debugger
 
-
-
 //     }
 
 //     var fields_changed = [];
@@ -6082,8 +5407,6 @@ func.datasource.update = async function (
 //               console.error(err);
 //             }
 
-
-
 //             if (!fields_changed.includes(field_id)) {
 //               fields_changed.push(field_id);
 //             }
@@ -6127,14 +5450,12 @@ func.datasource.update = async function (
 //           _ds.data_feed.rows_changed.push(record_id);
 //       }
 
-
 //       let new_datasource_changes = { ...datasource_changes, ...fieldComputed_datasource_changes }
 
 //       if (!update_local_scope_only) {
 //         if (glb.IS_WORKER) {
 //           let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
 
-
 //           if (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== "undefined" || typeof IS_PROCESS_SERVER !== "undefined") {
 //             continue;
 //           }
@@ -6191,55 +5512,53 @@ func.datasource.update = async function (
 //   });
 // };
 
-func.datasource.callback = function (
-  SESSION_ID,
-  dsSessionP,
-  na,
-  rowIdP,
-  jobNoP,
-  NA_callingDataSourceP,
-  NA_isInitP,
-  nodeIdP
-) {
+func.datasource.callback = async function (SESSION_ID, dsSessionP, na, rowIdP, jobNoP, NA_callingDataSourceP, NA_isInitP, nodeIdP) {
   var _session = SESSION_OBJ[SESSION_ID];
   var _ds = _session.DS_GLB[dsSessionP];
 
   try {
-    const row_idx = func.common.find_ROWID_idx(_ds, "dataset");
+    const row_idx = func.common.find_ROWID_idx(_ds, 'dataset');
 
     if (_ds.PARAM_OUT_INFO) {
       // write log for out params
       for (const [key, val] of Object.entries(_ds.PARAM_OUT_INFO)) {
-        if (
-          typeof _ds?.data_feed?.rows?.[row_idx]?.[val.fieldId] === "undefined"
-        ) {
+        if (typeof _ds?.data_feed?.rows?.[row_idx]?.[val.fieldId] === 'undefined') {
           // func.utils.debug.log(SESSION_ID, key, val);
-          func.utils.alerts.invoke(
-            SESSION_ID,
-            "system_msg",
-            "SYS_MSG_0310",
-            val.fieldId,
-            dsSessionP
-          );
+          func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0310', val.fieldId, dsSessionP);
           break;
         }
         val.result = _ds.data_feed.rows[row_idx][val.fieldId];
       }
     }
+
+    if (_ds?.progDataSource?.datasetOutputField) {
+      let datasource_changes = {};
+
+      let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
+      if (!datasource_changes[_ds.dsSession]) {
+        datasource_changes[_ds.dsSession] = {};
+      }
+      if (!datasource_changes[_ds.dsSession][_ds.currentRecordId]) {
+        datasource_changes[_ds.dsSession][_ds.currentRecordId] = {};
+
+        datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][_ds?.progDataSource?.datasetOutputField] = _ds?.data_feed?.rows || [];
+        await func.datasource.update(SESSION_ID, datasource_changes);
+      }
+    }
   } catch (err) {
     // console.error(err);
   }
 
   func.utils.debug.log(SESSION_ID, nodeIdP, {
     module: _ds.viewModule,
-    action: "close",
+    action: 'close',
     source: _ds.viewSourceDesc,
-    type: "adapter",
+    type: 'adapter',
     prog_id: _ds.prog_id,
     dsSession: dsSessionP,
-    prop: _ds.log_prop + " " + "adapter",
+    prop: _ds.log_prop + ' ' + 'adapter',
   });
-  if (!glb.IS_WORKER) $(_session.root_element).css("cursor", "default");
+  if (!glb.IS_WORKER) $(_session.root_element).css('cursor', 'default');
 
   if (_ds.prog_id) {
     let _ds = _session.DS_GLB[dsSessionP];
@@ -6247,19 +5566,17 @@ func.datasource.callback = function (
     func.utils.debug.watch(
       SESSION_ID,
       _ds.prog_id,
-      "program",
+      'program',
       {
         in_parameters: _ds.in_parameters,
         out_parameters: _ds.out_parameters,
         data_feed: _ds.data_feed,
       },
-      _ds.tree_obj.menuType
+      _ds.tree_obj.menuType,
     );
   }
   delete _ds.old_dataSource;
 
-
-
   return {
     SESSION_ID,
     dsSessionP,
@@ -6269,28 +5586,14 @@ func.datasource.callback = function (
     calling_jobP: _ds.calling_jobP,
   };
 };
-func.datasource.validate_viewRange = async function (
-  SESSION_ID,
-  viewRangeExpP,
-  dsSessionP,
-  rowIdP,
-  sourceP
-) {
+func.datasource.validate_viewRange = async function (SESSION_ID, viewRangeExpP, dsSessionP, rowIdP, sourceP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
   if (viewRangeExpP && _ds) {
-    var ret = func.expression.remove_quotes(
-      await func.expression.get(
-        SESSION_ID,
-        viewRangeExpP,
-        dsSessionP,
-        "range",
-        rowIdP
-      )
-    );
+    var ret = func.expression.remove_quotes(await func.expression.get(SESSION_ID, viewRangeExpP, dsSessionP, 'range', rowIdP));
     ret.result = func.expression.remove_quotes(ret.result);
     func.utils.debug.log(SESSION_ID, _ds.prog_id, {
       module: _ds.viewModule,
-      action: "range Exp",
+      action: 'range Exp',
       prop: sourceP,
       details: viewRangeExpP,
       result: ret.result,
@@ -6313,27 +5616,13 @@ func.datasource.validate_viewRange = async function (
     return ret.result;
   } else return false;
 };
-func.datasource.validate_viewLocate = async function (
-  SESSION_ID,
-  viewLocateExpP,
-  dsSessionP,
-  rowIdP,
-  sourceP
-) {
+func.datasource.validate_viewLocate = async function (SESSION_ID, viewLocateExpP, dsSessionP, rowIdP, sourceP) {
   if (viewLocateExpP && _ds) {
-    var ret = func.expression.remove_quotes(
-      await func.expression.get(
-        SESSION_ID,
-        viewLocateExpP,
-        dsSessionP,
-        "locate",
-        rowIdP
-      )
-    );
+    var ret = func.expression.remove_quotes(await func.expression.get(SESSION_ID, viewLocateExpP, dsSessionP, 'locate', rowIdP));
     ret.result = func.expression.remove_quotes(ret.result);
     func.utils.debug.log(SESSION_ID, _ds.prog_id, {
       module: _ds.viewModule,
-      action: "locate Exp",
+      action: 'locate Exp',
       prop: sourceP,
       details: viewLocateExpP,
       result: ret.result,
@@ -6348,12 +5637,7 @@ func.datasource.validate_viewLocate = async function (
   } else return false;
 };
 
-func.datasource.get_viewFields_for_update_function = function (
-  SESSION_ID,
-  calling_trigger_prop,
-  na,
-  dsSessionP
-) {
+func.datasource.get_viewFields_for_update_function = function (SESSION_ID, calling_trigger_prop, na, dsSessionP) {
   var viewFields = [];
 
   var exp = calling_trigger_prop?.data?.name?.value;
@@ -6362,7 +5646,7 @@ func.datasource.get_viewFields_for_update_function = function (
   }
   try {
     // parse json
-    var json = JSON5.parse(exp.replace(/\n/gi, ""));
+    var json = JSON5.parse(exp.replace(/\n/gi, ''));
     for (const [key, val] of Object.entries(json)) {
       let id = key.substr(1, key.length - 1);
       if (!id) continue;
@@ -6376,13 +5660,12 @@ func.datasource.get_viewFields_for_update_function = function (
     if (!exp) {
       return;
     }
-    if (exp.substr(exp.length - 1, 1) === ";")
-      exp = exp.substr(0, exp.length - 1); // remove closing if exist;
+    if (exp.substr(exp.length - 1, 1) === ';') exp = exp.substr(0, exp.length - 1); // remove closing if exist;
     var exp_arr = exp.split(/;\s*(?=(?:[^"]|"[^"]*")*$)/g); // split ; outside quotes
     if (exp_arr?.length) {
       for (let val of exp_arr) {
         // run view fields
-        var pos = val.indexOf(":");
+        var pos = val.indexOf(':');
         var seg = [val.substring(0, pos), val.substring(pos + 1)];
         if (seg && seg.length === 2) {
           let id = seg[0].substr(1, seg[0].length);
@@ -6395,14 +5678,14 @@ func.datasource.get_viewFields_for_update_function = function (
         } else {
           func.utils.debug.log(SESSION_ID, _ds.prog_id, {
             module: _ds.viewModule,
-            action: "set",
-            prop: "parse update exp",
+            action: 'set',
+            prop: 'parse update exp',
             details: exp,
-            result: "",
-            error: "Invalid json; too many segments",
+            result: '',
+            error: 'Invalid json; too many segments',
             source: _ds.viewSourceDesc,
-            json: "",
-            fields: "",
+            json: '',
+            fields: '',
             dsSession: dsSessionP,
           });
         }
@@ -6412,74 +5695,36 @@ func.datasource.get_viewFields_for_update_function = function (
     return viewFields;
   }
 };
-func.datasource.get_value = async function (
-  SESSION_ID,
-  fieldIdP,
-  dsSessionP,
-  rowIdP,
-  org_dsSessionP
-) {
+func.datasource.get_value = async function (SESSION_ID, fieldIdP, dsSessionP, rowIdP, org_dsSessionP) {
   const return_value = async (field_id, value) => {
-    const _progFields = await func.datasource.get_progFields(
-      SESSION_ID,
-      dsSessionP
-    );
-    let view_field_obj = func.common.find_item_by_key(
-      _progFields,
-      "field_id",
-      field_id
-    );
-    var fieldType = view_field_obj?.props?.fieldType || "string";
+    const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSessionP);
+    let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
+    var fieldType = view_field_obj?.props?.fieldType || 'string';
     var fieldProp = view_field_obj?.props;
     let table_field_obj;
-    if (view_field_obj?.data?.type === "table") {
+    if (view_field_obj?.data?.type === 'table') {
       if (!_ds._dataSourceTableId) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Datasource",
-          `Table type defined without dataSourceTableId deceleration`,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Datasource', `Table type defined without dataSourceTableId deceleration`, 'E');
       }
 
-      let table_obj = await func.utils.FILES_OBJ.get(
-        SESSION_ID,
-        _ds._dataSourceTableId
-      );
+      let table_obj = await func.utils.FILES_OBJ.get(SESSION_ID, _ds._dataSourceTableId);
 
       if (!table_obj) {
-        return func.utils.debug_report(
-          SESSION_ID,
-          "Datasource",
-          `dataSourceTableId reference error: ` + _ds._dataSourceTableId,
-          "E"
-        );
+        return func.utils.debug_report(SESSION_ID, 'Datasource', `dataSourceTableId reference error: ` + _ds._dataSourceTableId, 'E');
       }
-      table_field_obj = func.common.find_item_by_key(
-        table_obj.tableFields,
-        "field_id",
-        field_id
-      );
+      table_field_obj = func.common.find_item_by_key(table_obj.tableFields, 'field_id', field_id);
       fieldType = table_field_obj.props?.fieldType;
       fieldProp = table_field_obj.props;
     }
 
     let ret = {
-      value: await func.common.get_cast_val(
-        SESSION_ID,
-        `datasource get value ${_ds.tree_obj.menuName}`,
-        fieldIdP,
-        fieldType,
-        value,
-        null
-      ),
+      value: await func.common.get_cast_val(SESSION_ID, `datasource get value ${_ds.tree_obj.menuName}`, fieldIdP, fieldType, value, null),
       type: fieldType,
       prop: fieldProp,
     };
 
-    if (ret.value && typeof ret.value === "string" && ret.type !== "exp") {
-      if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
-        ret.value = ret.value.replace(/"/g, '"');
+    if (ret.value && typeof ret.value === 'string' && ret.type !== 'exp') {
+      if (/"/.test(ret.value) && ret.value.indexOf('\\') === -1) ret.value = ret.value.replace(/"/g, '"');
     }
 
     return {
@@ -6487,12 +5732,12 @@ func.datasource.get_value = async function (
       dsSessionP,
       fieldIdP: field_id,
       currentRecordId: _ds.currentRecordId,
-      found: typeof value !== "undefined",
+      found: typeof value !== 'undefined',
     };
   };
   const return_dynamic_value = async (field_id, value) => {
     let view_field_obj = _ds.dynamic_fields[field_id];
-    var fieldType = view_field_obj?.props?.fieldType || "string";
+    var fieldType = view_field_obj?.props?.fieldType || 'string';
     var fieldProp = view_field_obj?.props;
 
     let ret = {
@@ -6501,9 +5746,8 @@ func.datasource.get_value = async function (
       prop: fieldProp,
     };
 
-    if (ret.value && typeof ret.value === "string" && ret.type !== "exp") {
-      if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
-        ret.value = ret.value.replace(/"/g, '"');
+    if (ret.value && typeof ret.value === 'string' && ret.type !== 'exp') {
+      if (/"/.test(ret.value) && ret.value.indexOf('\\') === -1) ret.value = ret.value.replace(/"/g, '"');
     }
 
     return {
@@ -6511,26 +5755,18 @@ func.datasource.get_value = async function (
       dsSessionP,
       fieldIdP: field_id,
       currentRecordId: _ds.currentRecordId,
-      found: typeof value !== "undefined",
+      found: typeof value !== 'undefined',
     };
   };
   const return_value_parameters = async (field_id, value) => {
     let ret = {
-      value: await func.common.get_cast_val(
-        SESSION_ID,
-        "datasource get value",
-        fieldIdP,
-        value.type,
-        value.value,
-        null
-      ),
+      value: await func.common.get_cast_val(SESSION_ID, 'datasource get value', fieldIdP, value.type, value.value, null),
       type: value.type,
       prop: null,
     };
 
-    if (ret.value && typeof ret.value === "string" && ret.type !== "exp") {
-      if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
-        ret.value = ret.value.replace(/"/g, '"');
+    if (ret.value && typeof ret.value === 'string' && ret.type !== 'exp') {
+      if (/"/.test(ret.value) && ret.value.indexOf('\\') === -1) ret.value = ret.value.replace(/"/g, '"');
       // if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
       //   ret.value = ret.value.replace(/"/g, '\\"');
     }
@@ -6540,7 +5776,7 @@ func.datasource.get_value = async function (
       dsSessionP,
       fieldIdP: field_id,
       currentRecordId: _ds.currentRecordId,
-      found: typeof value !== "undefined",
+      found: typeof value !== 'undefined',
     };
   };
   const return_value_system = async (field_id, value) => {
@@ -6548,14 +5784,7 @@ func.datasource.get_value = async function (
     let fieldProp = null;
 
     let ret = {
-      value: await func.common.get_cast_val(
-        SESSION_ID,
-        `datasource get value ${_ds.tree_obj.menuName}`,
-        field_id,
-        fieldType,
-        value,
-        null
-      ),
+      value: await func.common.get_cast_val(SESSION_ID, `datasource get value ${_ds.tree_obj.menuName}`, field_id, fieldType, value, null),
       type: fieldType,
       prop: fieldProp,
     };
@@ -6565,52 +5794,35 @@ func.datasource.get_value = async function (
       dsSessionP,
       fieldIdP: field_id,
       currentRecordId: _ds.currentRecordId,
-      found: typeof value !== "undefined",
+      found: typeof value !== 'undefined',
     };
   };
   const search_in_parameters = async (field_id) => {
-    if (typeof _ds?.in_parameters?.[field_id]?.value !== "undefined") {
-      let ret = await return_value_parameters(
-        field_id,
-        _ds.in_parameters[field_id]
-      );
+    if (typeof _ds?.in_parameters?.[field_id]?.value !== 'undefined') {
+      let ret = await return_value_parameters(field_id, _ds.in_parameters[field_id]);
       return ret;
     }
 
-    if (typeof _ds.parentDataSourceNo !== "undefined") {
+    if (typeof _ds.parentDataSourceNo !== 'undefined') {
       var org_dsSession = org_dsSessionP;
       if (!org_dsSessionP) org_dsSession = dsSessionP;
-      if (recordId && recordId !== "newRecord") org_dsSession = null;
+      if (recordId && recordId !== 'newRecord') org_dsSession = null;
 
-      return await func.datasource.get_value(
-        SESSION_ID,
-        fieldIdP,
-        _ds.parentDataSourceNo,
-        recordId,
-        org_dsSession
-      );
+      return await func.datasource.get_value(SESSION_ID, fieldIdP, _ds.parentDataSourceNo, recordId, org_dsSession);
     }
 
     return await return_value(field_id);
   };
 
-  if (typeof glb.GLOBAL_VARS === "undefined") {
-    glb.GLOBAL_VARS = (
-      await func.common.get_module(SESSION_ID, "xuda-system-globals-module.mjs")
-    ).system_globals;
+  if (typeof glb.GLOBAL_VARS === 'undefined') {
+    glb.GLOBAL_VARS = (await func.common.get_module(SESSION_ID, 'xuda-system-globals-module.mjs')).system_globals;
   }
 
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
   if (!_ds) {
     if (dsSessionP > 0) {
       // let prev_ds = dsSessionP - 1;
-      return await func.datasource.get_value(
-        SESSION_ID,
-        fieldIdP,
-        dsSessionP - 1,
-        rowIdP,
-        org_dsSessionP
-      );
+      return await func.datasource.get_value(SESSION_ID, fieldIdP, dsSessionP - 1, rowIdP, org_dsSessionP);
     }
     return await return_value(fieldIdP);
   } //console.error("error: datasource not exist: " + dsSessionP);
@@ -6626,8 +5838,8 @@ func.datasource.get_value = async function (
     }
 
     if (dsSessionP > 0) {
-      _ds.data_system["SYS_STR_ACTIVE_ROW_ID"] = _ds.currentRecordId;
-      _ds.data_system["SYS_STR_PROG_DS_SESSION"] = dsSessionP;
+      _ds.data_system['SYS_STR_ACTIVE_ROW_ID'] = _ds.currentRecordId;
+      _ds.data_system['SYS_STR_PROG_DS_SESSION'] = dsSessionP;
     }
 
     // set system time
@@ -6638,19 +5850,15 @@ func.datasource.get_value = async function (
         if (!_ds_0.data_system) {
           _ds_0.data_system = {};
         }
-        const ts = await func.utils.get_dateTime(SESSION_ID, "SYS_DATE_VALUE");
+        const ts = await func.utils.get_dateTime(SESSION_ID, 'SYS_DATE_VALUE');
         for (const val of glb.SYS_DATE_ARR) {
-          _ds_0.data_system[val] = await func.utils.get_dateTime(
-            SESSION_ID,
-            val,
-            ts
-          );
+          _ds_0.data_system[val] = await func.utils.get_dateTime(SESSION_ID, val, ts);
         }
       }
     }
 
     // await func.datasource.set_system_vars(SESSION_ID, dsSessionP);
-    if (typeof _ds?.data_system?.[fieldIdP] !== "undefined") {
+    if (typeof _ds?.data_system?.[fieldIdP] !== 'undefined') {
       return await return_value_system(fieldIdP, _ds?.data_system?.[fieldIdP]);
     }
     return await search_in_parameters(fieldIdP);
@@ -6673,28 +5881,20 @@ func.datasource.get_value = async function (
 
   var _field_id = fieldIdP;
 
-  if (fieldIdP.substr(0, 1) === "_") {
+  if (fieldIdP.substr(0, 1) === '_') {
     if (_ds.alias) _field_id = _ds.alias[fieldIdP];
   }
 
   if (!org_dsSessionP && recordId) {
     try {
       const row_idx = func.common.find_ROWID_idx(_ds, recordId);
-      if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== "undefined") {
-        if (
-          Object.keys(_ds.data_feed?.rows?.[row_idx] || {})?.includes(_field_id)
-        ) {
-          return await return_value(
-            _field_id,
-            _ds.data_feed.rows[row_idx][_field_id]
-          );
+      if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== 'undefined') {
+        if (Object.keys(_ds.data_feed?.rows?.[row_idx] || {})?.includes(_field_id)) {
+          return await return_value(_field_id, _ds.data_feed.rows[row_idx][_field_id]);
         }
 
         if (Object.keys(_ds?.dynamic_fields || {})?.includes(_field_id)) {
-          return await return_dynamic_value(
-            _field_id,
-            _ds.dynamic_fields[_field_id]
-          );
+          return await return_dynamic_value(_field_id, _ds.dynamic_fields[_field_id]);
         }
       }
     } catch (err) {
@@ -6705,26 +5905,19 @@ func.datasource.get_value = async function (
   try {
     const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
 
-    if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== "undefined") {
-      return await return_value(
-        _field_id,
-        _ds.data_feed.rows[row_idx][_field_id]
-      );
+    if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== 'undefined') {
+      return await return_value(_field_id, _ds.data_feed.rows[row_idx][_field_id]);
     }
-  } catch (error) { }
+  } catch (error) {}
 
-  if (typeof _ds?.dynamic_fields?.[_field_id] !== "undefined") {
+  if (typeof _ds?.dynamic_fields?.[_field_id] !== 'undefined') {
     return await return_dynamic_value(_field_id, _ds.dynamic_fields[_field_id]);
   }
 
   return await search_in_parameters(fieldIdP);
 };
 
-func.datasource.find_event_dataSource = async function (
-  SESSION_ID,
-  eventIdP,
-  dsSessionP
-) {
+func.datasource.find_event_dataSource = async function (SESSION_ID, eventIdP, dsSessionP) {
   const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
   var ret;
   //============================
@@ -6732,14 +5925,10 @@ func.datasource.find_event_dataSource = async function (
   //============================
   if (_ds?.prog_id) {
     let view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
-    if (
-      view_ret?.progEvents &&
-      func.common.find_item_by_key(view_ret.progEvents, "event_name", eventIdP)
-    ) {
+    if (view_ret?.progEvents && func.common.find_item_by_key(view_ret.progEvents, 'event_name', eventIdP)) {
       ret = dsSessionP;
-      if (_ds.callingSource === "system") ret = 0;
-      if (_ds.callingSource === "program" || !_ds.callingSource)
-        ret = dsSessionP;
+      if (_ds.callingSource === 'system') ret = 0;
+      if (_ds.callingSource === 'program' || !_ds.callingSource) ret = dsSessionP;
       // >>> found value
       return ret;
     }
@@ -6748,46 +5937,24 @@ func.datasource.find_event_dataSource = async function (
     //=======================================
     // continue Search in parent datasource
     //=======================================
-    if (
-      _ds &&
-      _ds.parentDataSourceNo &&
-      Number(_ds.parentDataSourceNo) > 0 &&
-      Number(_ds.parentDataSourceNo) < dsSessionP
-    ) {
-      return await func.datasource.find_event_dataSource(
-        SESSION_ID,
-        eventIdP,
-        _ds.parentDataSourceNo
-      );
+    if (_ds && _ds.parentDataSourceNo && Number(_ds.parentDataSourceNo) > 0 && Number(_ds.parentDataSourceNo) < dsSessionP) {
+      return await func.datasource.find_event_dataSource(SESSION_ID, eventIdP, _ds.parentDataSourceNo);
     } else {
       //========================================
       // continue Search in global system
       //=========================================
-      if (!ret)
-        return await func.datasource.find_event_dataSource(
-          SESSION_ID,
-          eventIdP,
-          0
-        );
+      if (!ret) return await func.datasource.find_event_dataSource(SESSION_ID, eventIdP, 0);
     }
   }
 };
 func.datasource.reset_jobs = function (SESSION_ID, dsSessionP, sourceP, errP) {
-  for (const [key, val] of Object.entries(
-    SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs
-  )) {
+  for (const [key, val] of Object.entries(SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs)) {
     if (val.dsSessionP === dsSessionP) {
       func.events.delete_job(SESSION_ID, val.job_num);
       break;
     }
   }
-  func.utils.debug_report(
-    SESSION_ID,
-    sourceP + "Missing datasource: " + dsSessionP,
-    errP,
-    "W",
-    null
-  );
+  func.utils.debug_report(SESSION_ID, sourceP + 'Missing datasource: ' + dsSessionP, errP, 'W', null);
 };
 // func.datasource.set_system_vars = async function (SESSION_ID, dsSessionP) {
 //   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
@@ -6831,13 +5998,9 @@ func.datasource.reset_jobs = function (SESSION_ID, dsSessionP, sourceP, errP) {
 //     _ds_0.data_system[val] = await func.utils.get_dateTime(SESSION_ID, val, ts);
 //   }
 // };
-func.datasource.get_currentRecordId = function (
-  SESSION_ID,
-  dsSessionP,
-  from_datasourceP
-) {
+func.datasource.get_currentRecordId = function (SESSION_ID, dsSessionP, from_datasourceP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
-  if (_ds._dataSourceTableId !== "") {
+  if (_ds._dataSourceTableId !== '') {
     var firstRecordId = _ds.firstRecordId; // returns the value of the fist row
     var currentRecordId = _ds.currentRecordId; // record id that exist on ds after entering the form
     var locatedRecordId = _ds.locatedRecordId; // record id located by ds
@@ -6847,7 +6010,7 @@ func.datasource.get_currentRecordId = function (
       // set first row when no rec located
       else currentRecordId = locatedRecordId; // set with located row
     }
-  } else currentRecordId = "newRecord"; // create mode
+  } else currentRecordId = 'newRecord'; // create mode
   return currentRecordId;
 };
 func.datasource.interval = function (session_id, dsSessionP, typeP) {
@@ -6874,34 +6037,19 @@ func.datasource.interval = function (session_id, dsSessionP, typeP) {
           interval.push(
             setInterval(async function () {
               if (!SESSION_OBJ[SESSION_ID]) return;
-              var event_count = await func.datasource.get_view_events_count(
-                SESSION_ID,
-                dsSessionP,
-                typeP,
-                event_id
-              );
+              var event_count = await func.datasource.get_view_events_count(SESSION_ID, dsSessionP, typeP, event_id);
               if (!event_count) {
                 fx.clear();
                 return;
               }
-              var event_condition = await func.expression.get(
-                SESSION_ID,
-                condition,
-                dsSessionP,
-                "condition"
-              ); // execute condition;
+              var event_condition = await func.expression.get(SESSION_ID, condition, dsSessionP, 'condition'); // execute condition;
               if (condition && !event_condition.result) return;
 
-              const e = await func.datasource.execute_view_events(
-                SESSION_ID,
-                dsSessionP,
-                typeP,
-                event_id
-              );
+              const e = await func.datasource.execute_view_events(SESSION_ID, dsSessionP, typeP, event_id);
               // for (const [key, val] of Object.entries(e)) {
               //   val.done = false;
               // }
-            }, Number(interval_rate) * 1000)
+            }, Number(interval_rate) * 1000),
           );
         }
       } else {
@@ -6910,8 +6058,7 @@ func.datasource.interval = function (session_id, dsSessionP, typeP) {
       }
     },
     clear: function () {
-      if (DATASOURCE_INTERVALS[session_id])
-        delete DATASOURCE_INTERVALS[session_id][dsSessionP];
+      if (DATASOURCE_INTERVALS[session_id]) delete DATASOURCE_INTERVALS[session_id][dsSessionP];
       for (const [key, val] of Object.entries(interval)) {
         clearInterval(val);
       }
@@ -6924,12 +6071,8 @@ func.datasource.server_cron = function (session_id) {
   var jobs = [];
   // var ds = SESSION_OBJ[SESSION_ID].DS_GLB[0];
   // var v = ds.v;
-  var arr = func.datasource.get_event_interval_arr(
-    SESSION_ID,
-    0,
-    "server_cron"
-  );
-  const schedule = require("node-schedule");
+  var arr = func.datasource.get_event_interval_arr(SESSION_ID, 0, 'server_cron');
+  const schedule = require('node-schedule');
 
   if (!arr.length) {
     return jobs;
@@ -6942,75 +6085,43 @@ func.datasource.server_cron = function (session_id) {
     jobs.push(
       schedule.scheduleJob(cron_prop, async function () {
         if (!SESSION_OBJ[SESSION_ID]) return;
-        var event_count = await func.datasource.get_view_events_count(
-          SESSION_ID,
-          0,
-          "server_cron",
-          event_id
-        );
+        var event_count = await func.datasource.get_view_events_count(SESSION_ID, 0, 'server_cron', event_id);
         if (!event_count) {
           fx.clear();
           return;
         }
-        var event_condition = await func.expression.get(
-          SESSION_ID,
-          condition,
-          0,
-          "condition"
-        ); // execute condition;
+        var event_condition = await func.expression.get(SESSION_ID, condition, 0, 'condition'); // execute condition;
         if (condition && !event_condition.result) return;
         if (event_count) {
-          const e = await func.datasource.execute_view_events(
-            SESSION_ID,
-            0,
-            "server_cron",
-            event_id
-          );
+          const e = await func.datasource.execute_view_events(SESSION_ID, 0, 'server_cron', event_id);
           // for (const [key, val] of Object.entries(e)) {
           //   val.done = false;
           // }
         }
-      })
+      }),
     );
   }
 
   return jobs;
 };
-func.datasource.get_viewLoops = async function (
-  SESSION_ID,
-  dataSourceSession,
-  data,
-  batch_source,
-  default_limit
-) {
+func.datasource.get_viewLoops = async function (SESSION_ID, dataSourceSession, data, batch_source, default_limit) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   var args = _ds.args;
   // var v = _ds.v;
   var ret = default_limit;
 
-  if (batch_source === "db_data") ret = _.size(data.rows);
-  if (batch_source === "array" || batch_source === "csv") ret = data.length;
-  if (batch_source === "json") ret = Object.keys(data).length;
+  if (batch_source === 'db_data') ret = _.size(data.rows);
+  if (batch_source === 'array' || batch_source === 'csv') ret = data.length;
+  if (batch_source === 'json') ret = Object.keys(data).length;
   if (_ds.progDataSource?.dataSourceLimit) {
-    if (
-      batch_source !== "no_data" &&
-      Number(_ds.progDataSource?.dataSourceLimit) < ret
-    ) {
+    if (batch_source !== 'no_data' && Number(_ds.progDataSource?.dataSourceLimit) < ret) {
       ret = Number(_ds.progDataSource.dataSourceLimit);
     }
     if (!batch_source) ret = Number(_ds.progDataSource.dataSourceLimit);
   }
   if (prog_obj.progDataSource?.dataSourceLoopExp) {
-    var n = (
-      await func.expression.get(
-        SESSION_ID,
-        _ds.v.viewLoopsExp,
-        dataSourceSession,
-        "view_loop",
-        args.rowIdP
-      )
-    ).result;
-    if (batch_source !== "no_data" && n < ret) ret = n;
+    var n = (await func.expression.get(SESSION_ID, _ds.v.viewLoopsExp, dataSourceSession, 'view_loop', args.rowIdP)).result;
+    if (batch_source !== 'no_data' && n < ret) ret = n;
     if (!batch_source) ret = n;
   }
   return ret;
@@ -7022,13 +6133,11 @@ func.datasource.set_VIEW_data = async function (SESSION_ID, args, _ds) {
     segTo: [],
     segLocateFrom: [],
     segLocateTo: [],
-    viewModule: "adapter",
+    viewModule: 'adapter',
   };
   _ds.viewEventExec_arr = {};
 
-  var view = _.cloneDeep(
-    await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id)
-  );
+  var view = _.cloneDeep(await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id));
 
   _ds.v.dataSourceSrcType = view.dataSourceSrcType;
 
@@ -7044,7 +6153,7 @@ func.datasource.set_VIEW_data = async function (SESSION_ID, args, _ds) {
   }
 
   if (glb.FUNCTION_NODES_ARR.includes(tree_ret.menuType)) {
-    _ds.v.viewModule = "function";
+    _ds.v.viewModule = 'function';
   }
   _ds.v.viewSourceProp = tree_ret.menuType;
   if (view.progEvents) _ds.v.progEvents = view.progEvents;
@@ -7058,15 +6167,7 @@ func.datasource.set_VIEW_data = async function (SESSION_ID, args, _ds) {
   }
 };
 
-func.datasource.get_cast_val = async function (
-  SESSION_ID,
-  source,
-  dsSession,
-  valP,
-  typeP,
-  req,
-  error
-) {
+func.datasource.get_cast_val = async function (SESSION_ID, source, dsSession, valP, typeP, req, error) {
   var prog_id, prog_name;
   var _session = SESSION_OBJ[SESSION_ID];
   var _ds = _session.DS_GLB[dsSession];
@@ -7074,73 +6175,39 @@ func.datasource.get_cast_val = async function (
   prog_id = _ds.prog_id;
   prog_name = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id).menuName;
 
-  const prog_info = prog_id ? ` (prog: ${prog_id} ${prog_name})` : "";
+  const prog_info = prog_id ? ` (prog: ${prog_id} ${prog_name})` : '';
 
   const report_conversion_error = function (res) {
     var msg = `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 = `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"
-  );
-  return module.cast(
-    typeP,
-    valP,
-    report_conversion_error,
-    report_conversion_warn
-  );
+  const module = await func.common.get_module(SESSION_ID, 'xuda-get-cast-util-module.mjs');
+  return module.cast(typeP, valP, report_conversion_error, report_conversion_warn);
 };
-func.datasource.get_field_init_triggers_to_run = function (
-  SESSION_ID,
-  dataSourceSession,
-  pre_init_fieldsP
-) {
+func.datasource.get_field_init_triggers_to_run = function (SESSION_ID, dataSourceSession, pre_init_fieldsP) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   if (!_ds) return;
 
   return []; // inactive 021617
 }; // inactive temporary, design to execute init triggers when querying large datasets
-func.datasource.get_pre_init_fields = function (
-  SESSION_ID,
-  dsSessionP,
-  viewRangeExpP,
-  viewSortExpP,
-  viewGroupByExpP,
-  viewLocateExpP
-) {
+func.datasource.get_pre_init_fields = function (SESSION_ID, dsSessionP, viewRangeExpP, viewSortExpP, viewGroupByExpP, viewLocateExpP) {
   var ret = [];
   return; // inactive 021617
 }; // temporary inactive, init preformed on the first round
 
-func.datasource.add_dynamic_field_to_ds = function (
-  SESSION_ID,
-  dsSessionP,
-  key,
-  val
-) {
+func.datasource.add_dynamic_field_to_ds = function (SESSION_ID, dsSessionP, key, val) {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
   if (!_ds.dynamic_fields) {
     _ds.dynamic_fields = {};
@@ -7156,11 +6223,11 @@ func.datasource.add_dynamic_field_to_ds = function (
   _ds.dynamic_fields[key] = {
     id: crypto.randomUUID(),
     data: {
-      type: "virtual",
+      type: 'virtual',
       field_id: key,
     },
     props: {
-      fieldType: typeof (val) !== "undefined" ? toType(val) : "string",
+      fieldType: typeof val !== 'undefined' ? toType(val) : 'string',
     },
     value: val,
   };
@@ -7171,11 +6238,7 @@ func.datasource.get_progFields = async function (SESSION_ID, dsSessionP) {
   const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
   return _view_obj.progFields;
 };
-func.datasource.update_changes_for_out_parameter = async function (
-  SESSION_ID,
-  dsSessionP,
-  calling_dsP
-) {
+func.datasource.update_changes_for_out_parameter = async function (SESSION_ID, dsSessionP, calling_dsP) {
   let _session = SESSION_OBJ[SESSION_ID];
   let _ds = _session.DS_GLB[dsSessionP];
   const _calling_ds = _session.DS_GLB[calling_dsP];
@@ -7183,7 +6246,7 @@ func.datasource.update_changes_for_out_parameter = async function (
   if (_ds.PARAM_OUT_INFO) {
     let data = {};
     for await (const [key, val] of Object.entries(_ds.PARAM_OUT_INFO)) {
-      if (val.prop === "out") {
+      if (val.prop === 'out') {
         try {
           const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
           data[val.details] = _ds.data_feed.rows[row_idx][val.fieldId];
@@ -7205,50 +6268,31 @@ func.datasource.set_outputField = async function (SESSION_ID, dsSessionP, result
   var _session = SESSION_OBJ[SESSION_ID];
   // let _ds = _session.DS_GLB[dsSessionP];
 
-
-  const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSessionP, args, "outputField")
-
+  const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSessionP, args, 'outputField');
 
   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
-      ] = result;
+      datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][output_field] = result;
       await func.datasource.update(SESSION_ID, datasource_changes);
     }
   }
-
-}
+};
 
 func.datasource.get_args_property_value = async function (SESSION_ID, dsSession, args, prop_name) {
   let _prop = args?.calling_trigger_prop?.data?.name;
   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;