@xuda.io/runtime-bundle 1.0.518 → 1.0.519

package/js/xuda-runtime-bundle.js

@@ -30161,201 +30161,201 @@ func.datasource.del = function (SESSION_ID, dsP) {
   }
   perform_delete();
 };
-func.datasource.update_old = 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 (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;
-        } else {
-          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') {
-          // check if field has fieldComputed property
-          const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSession);
-          // find if field is computed
-          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;
-
-            const _propExpressions = val.props?.propExpressions?.fieldValue;
-            if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
-              fieldComputed_propExpressions = _propExpressions;
-              fieldComputed_id = fieldId;
-            }
-          }
+// func.datasource.update_old = 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 (!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;
-              try {
-                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);
-                  }
-                  if (!datasource_changed.includes(dsSession)) {
-                    datasource_changed.push(dsSession);
-                  }
-                }
-              } catch (err) {
-                console.error(err);
-              }
-            }
-          }
-        }
-        await set_fieldComputed_dependencies(dsNo, field_id, dsSession);
-      }
-    };
+//     if (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== 'undefined' || typeof IS_PROCESS_SERVER !== 'undefined') {
+//       update_local_scope_only = true;
+//     }
 
-    var fields_changed = [];
-    var datasource_changed = [];
-    let client_datasource_changes = {};
-    let server_datasource_changes = {};
-    // iterate changes datasource
-    for await (const [dataSource, row_data] of Object.entries(datasource_changes)) {
-      var _ds = _session.DS_GLB[dataSource];
-      if (!_ds) {
-        continue;
-      }
+//     if (typeof glb.GLOBAL_VARS === 'undefined') {
+//       glb.GLOBAL_VARS = (await func.common.get_module(SESSION_ID, 'xuda-system-globals-module.mjs')).system_globals;
+//     }
 
-      const update_xu_ref = async function () {
-        let _ds_0 = _session.DS_GLB[0];
-        for ([ref_name, val] of Object.entries(_ds_0.data_system['SYS_GLOBAL_OBJ_REFS'])) {
-          if (val.ds.dsSession == dataSource) {
-            func.UI.update_xu_ref(SESSION_ID, dataSource, ref_name);
-          }
-        }
-      };
+//     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;
+//         } else {
+//           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') {
+//           // check if field has fieldComputed property
+//           const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSession);
+//           // find if field is computed
+//           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;
+
+//             const _propExpressions = val.props?.propExpressions?.fieldValue;
+//             if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
+//               fieldComputed_propExpressions = _propExpressions;
+//               fieldComputed_id = fieldId;
+//             }
+//           }
 
-      // iterate changes records
-      for (const [record_id, fields_data] of Object.entries(row_data)) {
-        // 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') {
-            _.set(_ds, field_id, value);
-            update_xu_ref();
-            continue;
-          }
+//           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;
+//               try {
+//                 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);
+//                   }
+//                   if (!datasource_changed.includes(dsSession)) {
+//                     datasource_changed.push(dsSession);
+//                   }
+//                 }
+//               } catch (err) {
+//                 console.error(err);
+//               }
+//             }
+//           }
+//         }
+//         await set_fieldComputed_dependencies(dsNo, field_id, dsSession);
+//       }
+//     };
+
+//     var fields_changed = [];
+//     var datasource_changed = [];
+//     let client_datasource_changes = {};
+//     let server_datasource_changes = {};
+//     // iterate changes datasource
+//     for await (const [dataSource, row_data] of Object.entries(datasource_changes)) {
+//       var _ds = _session.DS_GLB[dataSource];
+//       if (!_ds) {
+//         continue;
+//       }
 
-          if (typeof fields_data === 'object') {
-            if (glb.GLOBAL_VARS[field_id]) {
-              _ds.data_system[field_id] = value;
-              continue;
-            }
+//       const update_xu_ref = async function () {
+//         let _ds_0 = _session.DS_GLB[0];
+//         for ([ref_name, val] of Object.entries(_ds_0.data_system['SYS_GLOBAL_OBJ_REFS'])) {
+//           if (val.ds.dsSession == dataSource) {
+//             func.UI.update_xu_ref(SESSION_ID, dataSource, ref_name);
+//           }
+//         }
+//       };
 
-            // try {
-            const row_idx = func.common.find_ROWID_idx(_ds, record_id);
-            if (_ds.data_feed.rows[row_idx][field_id] !== value) {
-              _ds.data_feed.rows[row_idx][field_id] = value;
-              await set_fieldComputed_dependencies(dataSource, field_id, null);
+//       // iterate changes records
+//       for (const [record_id, fields_data] of Object.entries(row_data)) {
+//         // 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') {
+//             _.set(_ds, field_id, value);
+//             update_xu_ref();
+//             continue;
+//           }
 
-              // search the field in refs
-              update_xu_ref();
+//           if (typeof fields_data === 'object') {
+//             if (glb.GLOBAL_VARS[field_id]) {
+//               _ds.data_system[field_id] = value;
+//               continue;
+//             }
 
-              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 (!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][field_id] = value;
-                    }
-                  }
-                } else {
-                  // RUN AT CLIENT
-                  if ((tree_ret.menuType === 'component' && _ds._run_at !== 'client') || tree_ret.menuType === 'globals') {
-                    if (!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][field_id] = value;
-                  }
-                }
-              }
+//             // try {
+//             const row_idx = func.common.find_ROWID_idx(_ds, record_id);
+//             if (_ds.data_feed.rows[row_idx][field_id] !== value) {
+//               _ds.data_feed.rows[row_idx][field_id] = value;
+//               await set_fieldComputed_dependencies(dataSource, field_id, null);
+
+//               // search the field in refs
+//               update_xu_ref();
+
+//               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 (!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][field_id] = value;
+//                     }
+//                   }
+//                 } else {
+//                   // RUN AT CLIENT
+//                   if ((tree_ret.menuType === 'component' && _ds._run_at !== 'client') || tree_ret.menuType === 'globals') {
+//                     if (!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][field_id] = value;
+//                   }
+//                 }
+//               }
 
-              if (!fields_changed.includes(field_id)) {
-                fields_changed.push(field_id);
-              }
-              if (!datasource_changed.includes(dataSource)) {
-                datasource_changed.push(dataSource);
-              }
+//               if (!fields_changed.includes(field_id)) {
+//                 fields_changed.push(field_id);
+//               }
+//               if (!datasource_changed.includes(dataSource)) {
+//                 datasource_changed.push(dataSource);
+//               }
 
-              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') {
-            _ds.currentRecordId = record_id;
-          }
-        }
-      }
-    }
+//               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') {
+//             _ds.currentRecordId = 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);
-      }
-    } 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',
-          data: {
-            session_id: SESSION_ID,
-            datasource_changes: server_datasource_changes,
-          },
-          id: _ds.worker_id,
-        });
-      }
-      ///// REFRESH SCREEN
-      if (!avoid_refresh && fields_changed.length) {
-        await func.UI.screen.refresh_xu_attributes(SESSION_ID, fields_changed);
-        // await removed from the below function cause to dead lock Mar 3 25
-        func.UI.screen.refresh_screen(
-          SESSION_ID,
-          fields_changed,
-          null,
-          datasource_changed[0], // refresh the current datasource only
-        );
-      }
-    }
-    resolve();
-  });
-};
+//     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);
+//       }
+//     } 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',
+//           data: {
+//             session_id: SESSION_ID,
+//             datasource_changes: server_datasource_changes,
+//           },
+//           id: _ds.worker_id,
+//         });
+//       }
+//       ///// REFRESH SCREEN
+//       if (!avoid_refresh && fields_changed.length) {
+//         await func.UI.screen.refresh_xu_attributes(SESSION_ID, fields_changed);
+//         // await removed from the below function cause to dead lock Mar 3 25
+//         func.UI.screen.refresh_screen(
+//           SESSION_ID,
+//           fields_changed,
+//           null,
+//           datasource_changed[0], // refresh the current datasource only
+//         );
+//       }
+//     }
+//     resolve();
+//   });
+// };
 
 func.datasource.update = async function (SESSION_ID, datasource_changes, update_local_scope_only, avoid_refresh) {
   return new Promise(async (resolve, reject) => {
@@ -30430,6 +30430,19 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
     var datasource_changed = [];
     let client_datasource_changes = {};
     let server_datasource_changes = {};
+
+    const update_xu_ref = async function (dataSource, field_id) {
+      let ret;
+      let _ds_0 = _session.DS_GLB[0];
+      for ([ref_name, val] of Object.entries(_ds_0.data_system['SYS_GLOBAL_OBJ_REFS'])) {
+        if (val.ds.dsSession == dataSource) {
+          func.UI.update_xu_ref(SESSION_ID, dataSource, ref_name);
+          ret = true;
+        }
+      }
+      return ret;
+    };
+
     // iterate changes datasource
     for await (const [dataSource, row_data] of Object.entries(datasource_changes)) {
       var _ds = _session.DS_GLB[dataSource];
@@ -30437,15 +30450,6 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
         continue;
       }
 
-      const update_xu_ref = async function () {
-        let _ds_0 = _session.DS_GLB[0];
-        for ([ref_name, val] of Object.entries(_ds_0.data_system['SYS_GLOBAL_OBJ_REFS'])) {
-          if (val.ds.dsSession == dataSource) {
-            func.UI.update_xu_ref(SESSION_ID, dataSource, ref_name);
-          }
-        }
-      };
-
       // iterate changes records
       for (const [record_id, fields_data] of Object.entries(row_data)) {
         // iterate changes fields
@@ -30453,9 +30457,11 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
           // mechanism to make update directly on the datasource object
           if (record_id === 'datasource_main') {
             _.set(_ds, field_id, value);
-            update_xu_ref();
-            fields_changed.push(field_id);
-            datasource_changed.push(dataSource);
+            const ret = update_xu_ref(dataSource, field_id);
+            if (ret) {
+              fields_changed.push(field_id);
+              datasource_changed.push(dataSource);
+            }
             continue;
           }
 
@@ -30472,7 +30478,7 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
               await set_fieldComputed_dependencies(dataSource, field_id, null);
 
               // search the field in refs
-              update_xu_ref();
+              update_xu_ref(dataSource, field_id);
 
               if (!update_local_scope_only) {
                 let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);