npm - @xuda.io/runtime-bundle - Versions diffs - 1.0.286 → 1.0.287 - Mend

@xuda.io/runtime-bundle 1.0.286 → 1.0.287

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/js/xuda-runtime-bundle.js +494 -1450
package/js/xuda-runtime-bundle.min.js +1 -1
package/js/xuda-runtime-slim.js +497 -1453
package/js/xuda-runtime-slim.min.es.js +497 -1453
package/js/xuda-runtime-slim.min.js +1 -1
package/js/xuda-server-bundle.min.mjs +1 -1
package/js/xuda-server-bundle.mjs +493 -1449
package/js/xuda-worker-bundle.js +493 -1449
package/js/xuda-worker-bundle.min.js +1 -1
package/package.json +1 -1

package/js/xuda-runtime-bundle.js CHANGED Viewed

@@ -28517,15 +28517,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,
@@ -28557,8 +28557,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];
@@ -28570,26 +28569,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) {
@@ -28601,12 +28594,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();
         }
       }
@@ -28621,8 +28609,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,
             },
@@ -28636,7 +28624,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++;
             }
           }
@@ -28665,12 +28653,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,
@@ -28689,7 +28672,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);
     }
@@ -28698,19 +28681,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,
     });
@@ -28724,43 +28704,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,
@@ -28779,34 +28736,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);
           }
         }
@@ -28816,23 +28763,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,
@@ -28840,52 +28784,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 = {
@@ -28911,18 +28840,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++;
       }
@@ -28933,7 +28857,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 {
@@ -28946,13 +28870,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();
@@ -28962,7 +28886,7 @@ func.datasource.prepare = async function (
   };
   var _ds = await init_dataSource();
-  _ds.stat = "busy";
+  _ds.stat = 'busy';
   _ds._run_at = run_atP;
   // init_v();
@@ -28974,12 +28898,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);
@@ -28989,7 +28908,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 () {
@@ -29015,7 +28934,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();
@@ -29030,18 +28949,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) {
@@ -29050,22 +28961,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;
@@ -29074,60 +28977,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;
   };
@@ -29137,24 +29012,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;
     }
@@ -29163,10 +29027,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
@@ -29177,54 +29038,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,
     });
@@ -29237,47 +29083,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;
           }
@@ -29285,21 +29115,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;
         }
@@ -29319,76 +29139,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;
       }
@@ -29408,7 +29189,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,
@@ -29417,7 +29198,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(
@@ -29426,7 +29207,7 @@ func.datasource.execute = async function (
           _ds.v.couchView,
           dataSourceSession,
           _ds.viewSourceDesc,
-          "datasource table",
+          'datasource table',
           prog_obj.progDataSource.dataSourceReduce,
           null,
           null,
@@ -29435,7 +29216,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 {
@@ -29443,7 +29224,7 @@ func.datasource.execute = async function (
       }
       break;
-    case "array": {
+    case 'array': {
       let data = await get_data_from_source();
       if (data === null) {
@@ -29469,7 +29250,7 @@ func.datasource.execute = async function (
       break;
     }
-    case "json": {
+    case 'json': {
       let data = await get_data_from_source();
       if (data === null) {
         data = {};
@@ -29490,12 +29271,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) {
@@ -29514,7 +29293,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++;
@@ -29533,24 +29312,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 || [];
@@ -29559,7 +29330,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;
@@ -29568,47 +29339,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 || [];
@@ -29617,7 +29372,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;
@@ -29626,68 +29381,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 () {
@@ -29702,7 +29424,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);
@@ -29712,81 +29434,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;
         }
@@ -29795,7 +29498,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;
@@ -29806,49 +29509,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');
           }
         }
       };
@@ -29863,20 +29546,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;
       };
@@ -29884,11 +29560,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(
@@ -29902,28 +29574,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);
@@ -29932,11 +29589,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();
@@ -29944,82 +29597,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) {
@@ -30040,64 +29653,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) => {
@@ -30105,123 +29692,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;
@@ -30238,29 +29777,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;
             }
@@ -30269,39 +29799,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);
     }
   }
 };
@@ -30364,12 +29879,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];
@@ -30379,21 +29889,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;
@@ -30435,20 +29935,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;
@@ -30464,25 +29958,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;
         }
@@ -30516,14 +30000,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,
             },
@@ -30537,19 +30021,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 = {};
@@ -30563,18 +30042,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;
       }
@@ -30584,13 +30052,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,
@@ -30599,31 +30066,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"
-        );
+        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 (!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) {
@@ -30639,50 +30093,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,
@@ -30699,39 +30131,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;
@@ -30742,10 +30163,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);
       }
@@ -30754,11 +30172,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;
@@ -30771,13 +30185,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) {
@@ -30796,20 +30204,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 = [];
@@ -30850,19 +30254,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) {
@@ -30870,27 +30272,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);
       },
     };
@@ -30904,14 +30298,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();
@@ -30920,7 +30309,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,
         });
@@ -30936,7 +30325,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();
         }
       }
@@ -30944,23 +30333,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];
       }
@@ -30968,86 +30350,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) {
@@ -31056,19 +30415,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;
@@ -31078,12 +30434,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;
@@ -31093,42 +30449,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;
                   }
@@ -31148,14 +30495,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 = [];
@@ -31163,30 +30506,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,
@@ -31201,16 +30530,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,
@@ -31296,8 +30623,6 @@ func.datasource.update = async function (
 //       }
 //       debugger
 //     }
 //     var fields_changed = [];
@@ -31336,8 +30661,6 @@ func.datasource.update = async function (
 //               console.error(err);
 //             }
 //             if (!fields_changed.includes(field_id)) {
 //               fields_changed.push(field_id);
 //             }
@@ -31381,14 +30704,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;
 //           }
@@ -31445,55 +30766,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];
@@ -31501,19 +30820,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,
@@ -31523,28 +30840,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,
@@ -31567,27 +30870,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,
@@ -31602,12 +30891,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;
@@ -31616,7 +30900,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;
@@ -31630,13 +30914,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);
@@ -31649,14 +30932,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,
           });
         }
@@ -31666,74 +30949,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 {
@@ -31741,12 +30986,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 = {
@@ -31755,9 +31000,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 {
@@ -31765,26 +31009,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, '\\"');
     }
@@ -31794,7 +31030,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) => {
@@ -31802,14 +31038,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,
     };
@@ -31819,52 +31048,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);
@@ -31880,8 +31092,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
@@ -31892,19 +31104,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);
@@ -31927,28 +31135,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) {
@@ -31959,26 +31159,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;
   //============================
@@ -31986,14 +31179,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;
     }
@@ -32002,46 +31191,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];
@@ -32085,13 +31252,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
@@ -32101,7 +31264,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) {
@@ -32128,34 +31291,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 {
@@ -32164,8 +31312,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);
       }
@@ -32178,12 +31325,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;
@@ -32196,75 +31339,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;
@@ -32276,13 +31387,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;
@@ -32298,7 +31407,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;
@@ -32312,15 +31421,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];
@@ -32328,73 +31429,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 = {};
@@ -32410,11 +31477,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,
   };
@@ -32425,11 +31492,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];
@@ -32437,7 +31500,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];
@@ -32459,50 +31522,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;