@xuda.io/xuda-worker-bundle-min 1.3.2432 → 1.3.2433

package/index.js

@@ -11,9 +11,14 @@ func.UI = {};
 func.GLB = {};
 func.mobile = {};
 func.runtime = {};
+func.runtime.bind = {};
+func.runtime.program = {};
+func.runtime.resources = {};
+func.runtime.render = {};
 func.runtime.session = {};
 func.runtime.workers = {};
 func.runtime.ui = {};
+func.runtime.widgets = {};
 glb.IS_STUDIO = null;
 
 var PROJECT_OBJ = {};
@@ -429,134 +434,452 @@ func.runtime.workers.delete_promise = function (SESSION_ID, worker_id, promise_q
   delete registry_entry.promise_queue[promise_queue_id];
   return true;
 };
-func.runtime.ui.get_root_element = function (SESSION_ID) {
-  return $(SESSION_OBJ[SESSION_ID].root_element);
-};
-func.runtime.ui.show_root_element = function (SESSION_ID) {
-  const $root_element = func.runtime.ui.get_root_element(SESSION_ID);
-  $root_element.show();
-  return $root_element;
-};
-func.runtime.ui.ensure_app_shell = function (SESSION_ID, domain) {
-  const $root_element = func.runtime.ui.get_root_element(SESSION_ID);
-  $root_element.css('position', 'relative');
-
-  if (!$root_element.find('.loader').length) {
-    $root_element.append(`
-      
-          <style>
-          .loader {
-            position: absolute;
-            background: rgb(0 0 0 / 30%);
-            z-index: 10;
-            overflow-y: auto;
-            top: 0;
-            right: 0;
-            bottom: 0;
-            left: 0;
-            display: flex;
-            flex-direction: column;
-            justify-content: center;
-            align-items: center;
-          }
+func.runtime.render.get_root_data_system = function (SESSION_ID) {
+  return SESSION_OBJ[SESSION_ID]?.DS_GLB?.[0]?.data_system || null;
+};
+func.runtime.render.resolve_xu_for_source = async function (SESSION_ID, dsSessionP, value) {
+  let arr = value;
+  let reference_source_obj;
+  const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSessionP);
+  let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', value);
 
-          .loader .loader_logo {
+  if (view_field_obj) {
+    reference_source_obj = await func.datasource.get_value(SESSION_ID, value, dsSessionP);
+    arr = reference_source_obj?.ret?.value;
+  } else {
+    if (typeof value === 'string') {
+      arr = eval(value.replaceAll('\\', ''));
+    }
+    if (typeof arr === 'number') {
+      arr = Array.from(Array(arr).keys());
+    }
+  }
 
-            width: 43px;
-            height: 43px;
-            border-radius: 50%;
-            background-size: cover;
-          }
+  return {
+    arr,
+    reference_source_obj,
+  };
+};
+func.runtime.render.apply_iterate_value_to_ds = function (SESSION_ID, dsSessionP, currentRecordId, progFields, field_id, value, is_dynamic_field) {
+  if (is_dynamic_field) {
+    func.datasource.add_dynamic_field_to_ds(SESSION_ID, dsSessionP, field_id, value);
+    return true;
+  }
 
-          .loader .loader_msg {
-            padding-top: 10px;
-            text-align: center;
-            min-height: 20px;
-            font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
-          }
-    
-          .loader .loader_rotate {
-            padding: 20px;
-            border: 2px solid #fff;
-            border-right-color: #898989;
-            border-radius: 22px;
-            -webkit-animation: rotate 0.8s infinite linear;
-            position: absolute;
-          }
-    
-          @-webkit-keyframes rotate {
-            100% {
-              -webkit-transform: rotate(360deg);
-            }
+  let view_field_obj = func.common.find_item_by_key(progFields || [], 'field_id', field_id);
+  if (!view_field_obj) {
+    console.error('field not exist in dataset for xu-for method');
+    return false;
+  }
+
+  let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  try {
+    const row_idx = func.common.find_ROWID_idx(_ds, currentRecordId);
+    _ds.data_feed.rows[row_idx][field_id] = value;
+    return true;
+  } catch (err) {
+    console.error(err);
+    return false;
+  }
+};
+func.runtime.render.build_iterate_info = function (options) {
+  return {
+    _val: options._val,
+    _key: options._key,
+    iterator_key: options.iterator_key,
+    iterator_val: options.iterator_val,
+    is_key_dynamic_field: options.is_key_dynamic_field,
+    is_val_dynamic_field: options.is_val_dynamic_field,
+    reference_source_obj: options.reference_source_obj,
+  };
+};
+func.runtime.render.apply_iterate_info_to_current_record = function (SESSION_ID, dsSessionP, currentRecordId, progFields, iterate_info) {
+  if (!iterate_info) {
+    return false;
+  }
+  func.runtime.render.apply_iterate_value_to_ds(SESSION_ID, dsSessionP, currentRecordId, progFields, iterate_info.iterator_key, iterate_info._key, iterate_info.is_key_dynamic_field);
+  func.runtime.render.apply_iterate_value_to_ds(SESSION_ID, dsSessionP, currentRecordId, progFields, iterate_info.iterator_val, iterate_info._val, iterate_info.is_val_dynamic_field);
+  return true;
+};
+func.runtime.render.sync_iterate_info_to_dataset = function (_ds, iterate_info) {
+  if (!iterate_info) {
+    return false;
+  }
+
+  const sync_field = function (field_id, value, is_dynamic_field) {
+    if (is_dynamic_field) {
+      _ds.dynamic_fields[field_id].value = value;
+      return true;
+    }
+    try {
+      const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
+      _ds.data_feed.rows[row_idx][field_id] = value;
+      return true;
+    } catch (err) {
+      console.error(err);
+      return false;
+    }
+  };
+
+  sync_field(iterate_info.iterator_key, iterate_info._key, iterate_info.is_key_dynamic_field);
+  sync_field(iterate_info.iterator_val, iterate_info._val, iterate_info.is_val_dynamic_field);
+  return true;
+};
+func.runtime.program.get_params_obj = async function (SESSION_ID, prog_id, nodeP, dsSession) {
+  const _prog = await func.utils.VIEWS_OBJ.get(SESSION_ID, prog_id);
+  if (!_prog) return;
+
+  let params_res = {},
+    params_raw = {};
+  if (_prog?.properties?.progParams) {
+    for await (const [key, val] of Object.entries(_prog.properties.progParams)) {
+      if (!['in', 'out'].includes(val.data.dir)) continue;
+
+      if (nodeP.attributes) {
+        if (nodeP.attributes[val.data.parameter]) {
+          params_res[val.data.parameter] = nodeP.attributes[val.data.parameter];
+        } else if (nodeP.attributes[`xu-exp:${val.data.parameter}`]) {
+          if (val.data.dir == 'out') {
+            params_res[val.data.parameter] = nodeP.attributes[`xu-exp:${val.data.parameter}`].replaceAll('@', '');
+          } else {
+            let ret = await func.expression.get(SESSION_ID, nodeP.attributes[`xu-exp:${val.data.parameter}`], dsSession, 'parameters');
+            params_res[val.data.parameter] = ret.result;
+            params_raw[val.data.parameter] = nodeP.attributes[`xu-exp:${val.data.parameter}`];
           }
-      </style>
-      
-      <div class="loader">
-      <div class="loader_logo">
-        <div class="loader_rotate"></div> 
-      </div>
-      <div class="loader_msg"> </div>
-    </div>
-  
-      
-      <div class="progressLoader"></div>
-      
-      `);
-  }
-
-  if (!$root_element.find('#tailwind_toast_controller').length) {
-    $root_element.append(
-      `<div aria-live="assertive"
-          class="fixed inset-0 flex items-end px-4 py-6 pointer-events-none sm:p-6 sm:items-start z-[999]">
-          <div id="tailwind_toast_controller" class="w-full flex flex-col items-center space-y-4 sm:items-end">
-  
-          </div>
-       </div>`,
-    );
+        }
+        continue;
+      }
+      console.warn(`Warning: Program ${_prog.properties.menuName} expected In parameter: ${val.data.parameter} but received null instead`);
+    }
   }
+  return { params_res, params_raw };
+};
+func.runtime.bind.build_datasource_changes = function (dsSessionP, currentRecordId, field_id, value) {
+  return {
+    [dsSessionP]: {
+      [currentRecordId]: {
+        [field_id]: value,
+      },
+    },
+  };
+};
+func.runtime.bind.resolve_field = async function (SESSION_ID, prog_id, dsSessionP, field_id) {
+  let _prog_id = prog_id;
+  let _dsP = dsSessionP;
+  let is_dynamic_field = false;
+  let field_prop;
 
-  if (!$root_element.find('#progressScreen2').length) {
-    $root_element.append(
-      `
-        <div id="progressScreen2" style="display: none">
-          <div id="progressScreen2_text"></div>
-        </div>`,
-    );
+  const find_in_view = async function (field_id, prog_id) {
+    const view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, prog_id);
+    if (!view_ret) {
+      return null;
+    }
+    return func.common.find_item_by_key(view_ret.progFields, 'field_id', field_id);
+  };
+
+  if (['_FOR_VAL', '_FOR_KEY'].includes(field_id)) {
+    is_dynamic_field = true;
+    field_prop = SESSION_OBJ[SESSION_ID]?.DS_GLB?.[_dsP]?.dynamic_fields?.[field_id];
+  } else {
+    field_prop = await find_in_view(field_id, _prog_id);
+    if (!field_prop) {
+      const ret_get_value = await func.datasource.get_value(SESSION_ID, field_id, _dsP);
+      if (ret_get_value.found) {
+        _dsP = ret_get_value.dsSessionP;
+        let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[_dsP];
+        _prog_id = _ds.prog_id;
+        field_prop = await find_in_view(field_id, _prog_id);
+      }
+    }
+  }
+
+  if (!field_prop) {
+    throw `field ${field_id} not found in the program scope`;
   }
 
-  const get_url = function (domain, method, path) {
-    return `https://${domain}/${method}${path ? '/' + path : '/'}`;
+  return {
+    bind_field_id: field_id,
+    field_prop,
+    is_dynamic_field,
+    dsSessionP: _dsP,
+    prog_id: _prog_id,
   };
+};
+func.runtime.bind.get_field_type = function (field_prop) {
+  return field_prop?.props?.fieldType;
+};
+func.runtime.bind.toggle_array_value = function (arr_value_before_cast, value_from_getter) {
+  if (arr_value_before_cast.includes(value_from_getter)) {
+    return arr_value_before_cast.filter((item) => !_.isEqual(item, value_from_getter));
+  }
+  arr_value_before_cast.push(value_from_getter);
+  return arr_value_before_cast;
+};
+func.runtime.bind.get_cast_value = async function (SESSION_ID, field_prop, input_field_type, raw_value) {
+  const field_type = func.runtime.bind.get_field_type(field_prop);
+  var value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', field_type, raw_value);
+  if (field_type === 'object') {
+    value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', input_field_type, raw_value);
+  }
+  return value;
+};
+func.runtime.bind.get_source_value = function (_ds, bind_field_id, is_dynamic_field) {
+  if (is_dynamic_field) {
+    return _ds.dynamic_fields[bind_field_id].value;
+  }
+  const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
+  return _ds.data_feed.rows?.[row_idx]?.[bind_field_id];
+};
+func.runtime.bind.format_display_value = function ($elm, field_prop, bind_field_id, expression_value, value, input_field_type) {
+  const field_type = func.runtime.bind.get_field_type(field_prop);
+  const elm_value = $elm.attr('value');
 
-  func.utils.load_css_on_demand(get_url(domain, 'dist', 'runtime/css/mobile.css'));
-  return $root_element;
+  if (field_type === 'array' && input_field_type === 'checkbox' && elm_value) {
+    return value.includes(elm_value);
+  }
+  if (field_type === 'array' && input_field_type === 'radio' && elm_value) {
+    if (value.includes(elm_value)) {
+      return elm_value;
+    }
+    return false;
+  }
+  if (field_type === 'object' && expression_value.split('.').length > 1) {
+    let str = expression_value.replace(bind_field_id, '(' + JSON.stringify(value) + ')');
+    return eval(str);
+  }
+  return value;
 };
-func.runtime.ui.ensure_embed_container = function (SESSION_ID) {
-  const $root_element = func.runtime.ui.get_root_element(SESSION_ID);
-  let $embed_container = $root_element.find(`#embed_${SESSION_ID}`);
+func.runtime.bind.update_reference_source_array = async function (options) {
+  const field_type = func.runtime.bind.get_field_type(options.field_prop);
+  const reference_source_obj = options.iterate_info?.reference_source_obj;
+  if (!reference_source_obj || reference_source_obj.ret.type !== 'array' || options.iterate_info?.iterator_val !== options.bind_field_id) {
+    return false;
+  }
+
+  const arr_idx = Number(options.iterate_info._key);
+  const dataset_arr = await func.datasource.get_value(options.SESSION_ID, reference_source_obj.fieldIdP, options.dsSessionP, reference_source_obj.currentRecordId);
+  let new_arr = _.cloneDeep(dataset_arr.ret.value);
 
-  if (!$embed_container.length) {
-    $embed_container = $('<div>')
-      .attr('id', 'embed_' + SESSION_ID)
-      .addClass('xu_embed_div')
-      .data({ xuData: {} })
-      .appendTo($root_element);
+  if (field_type === 'object' && options.val_is_reference_field) {
+    let obj_item = new_arr[arr_idx];
+    let e_exp = options.expression_value.replace(options.bind_field_id, 'obj_item');
+    eval(e_exp + (options.input_field_type === 'string' ? `="${options.value}"` : `=${options.value}`));
+    new_arr[arr_idx] = obj_item;
+  } else {
+    new_arr[arr_idx] = options.value;
   }
 
-  return $embed_container;
+  let datasource_changes = func.runtime.bind.build_datasource_changes(options.dsSessionP, options.currentRecordId, reference_source_obj.fieldIdP, new_arr);
+  await func.datasource.update(options.SESSION_ID, datasource_changes, null, true);
+  return true;
 };
-func.runtime.ui.get_embed_container = function (SESSION_ID) {
-  return func.runtime.ui.get_root_element(SESSION_ID).find(`#embed_${SESSION_ID}`);
+func.runtime.resources.load_cdn = async function (SESSION_ID, resource) {
+  let normalized_resource = resource;
+  if (!_.isObject(normalized_resource) && _.isString(normalized_resource)) {
+    normalized_resource = { src: normalized_resource, type: 'js' };
+  }
+  if (!_.isObject(normalized_resource)) {
+    throw new Error('cdn resource in wrong format');
+  }
+
+  return new Promise(async (resolve) => {
+    try {
+      switch (normalized_resource.type) {
+        case 'js':
+          await func.utils.load_js_on_demand(normalized_resource.src);
+          break;
+        case 'css':
+          await func.utils.load_js_on_demand(normalized_resource.src);
+          break;
+        case 'module':
+          func.utils.load_js_on_demand(normalized_resource.src, 'module');
+          break;
+        default:
+          await func.utils.load_js_on_demand(normalized_resource.src);
+          break;
+      }
+      resolve();
+    } catch (error) {
+      func.utils.debug_report(SESSION_ID, 'xu-cdn', 'Fail to load: ' + normalized_resource, 'W');
+      resolve();
+    }
+  });
 };
-func.runtime.ui.get_embed_screen_containers = function () {
-  return $('.xu_embed_container');
+func.runtime.resources.get_plugin_manifest_entry = function (_session, plugin_name) {
+  return APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name] || null;
 };
-func.runtime.ui.append_to_body = function ($element) {
-  $element.appendTo('body');
-  return $element;
+func.runtime.resources.get_plugin_module_path = function (plugin, resource) {
+  const manifest_entry = plugin?.manifest?.[resource];
+  return `${manifest_entry?.dist ? 'dist/' : ''}${resource}`;
 };
-func.runtime.ui.find_in_root = function (SESSION_ID, selector) {
-  return func.runtime.ui.get_root_element(SESSION_ID).find(selector);
+func.runtime.resources.get_plugin_module_url = async function (SESSION_ID, plugin_name, plugin, resource) {
+  return await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, func.runtime.resources.get_plugin_module_path(plugin, resource));
+};
+func.runtime.resources.load_plugin_runtime_css = async function (SESSION_ID, plugin_name, plugin) {
+  if (!plugin?.manifest?.['runtime.mjs']?.dist || !plugin?.manifest?.['runtime.mjs']?.css) {
+    return false;
+  }
+  const plugin_runtime_css_url = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, 'dist/runtime.css');
+  func.utils.load_css_on_demand(plugin_runtime_css_url);
+  return true;
+};
+func.runtime.resources.resolve_plugin_properties = async function (SESSION_ID, dsSessionP, attributes, properties) {
+  let resolved_properties = _.cloneDeep(properties);
+  for await (let [prop_name, prop_val] of Object.entries(resolved_properties || {})) {
+    prop_val.value = attributes?.[prop_name];
+    if (attributes?.[`xu-exp:${prop_name}`]) {
+      const res = await func.expression.get(SESSION_ID, attributes[`xu-exp:${prop_name}`], dsSessionP, 'UI Attr EXP');
+      prop_val.value = res.result;
+    }
+  }
+  return resolved_properties;
+};
+func.runtime.resources.run_ui_plugin = async function (SESSION_ID, paramsP, $elm, plugin_name, value) {
+  var _session = SESSION_OBJ[SESSION_ID];
+  const plugin = func.runtime.resources.get_plugin_manifest_entry(_session, plugin_name);
+  if (!plugin?.installed || !plugin?.manifest?.['runtime.mjs']?.exist || !plugin?.manifest?.['index.mjs']?.exist || !value?.enabled) {
+    return false;
+  }
+
+  await func.runtime.resources.load_plugin_runtime_css(SESSION_ID, plugin_name, plugin);
+
+  const plugin_index_src = await func.runtime.resources.get_plugin_module_url(SESSION_ID, plugin_name, plugin, 'index.mjs');
+  const plugin_index_resources = await import(plugin_index_src);
+  const properties = await func.runtime.resources.resolve_plugin_properties(SESSION_ID, paramsP.dsSessionP, value?.attributes, plugin_index_resources.properties);
+
+  const plugin_runtime_src = await func.runtime.resources.get_plugin_module_url(SESSION_ID, plugin_name, plugin, 'runtime.mjs');
+  const plugin_runtime_resources = await import(plugin_runtime_src);
+
+  if (plugin_runtime_resources.cdn && _.isArray(plugin_runtime_resources.cdn)) {
+    for await (const resource of plugin_runtime_resources.cdn) {
+      await func.runtime.resources.load_cdn(SESSION_ID, resource);
+    }
+  }
+
+  if (plugin_runtime_resources.fn) {
+    await plugin_runtime_resources.fn(plugin_name, $elm?.[0], properties);
+  }
+  return true;
+};
+func.runtime.widgets.create_context = function (SESSION_ID, paramsP, prop) {
+  const _session = SESSION_OBJ[SESSION_ID];
+  const plugin_name = prop['xu-widget'];
+  return {
+    SESSION_ID,
+    _session,
+    plugin_name,
+    method: prop['xu-method'] || '_default',
+    dsP: paramsP.dsSessionP,
+    propsP: prop,
+    sourceP: 'widgets',
+    plugin: APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name] || null,
+  };
+};
+func.runtime.widgets.report_error = function (context, descP, warn) {
+  const program = context?._session?.DS_GLB?.[context.dsP];
+  if (!program) {
+    return null;
+  }
+  func.utils.debug.log(context.SESSION_ID, program.prog_id + '_' + program.callingMenuId, {
+    module: 'widgets',
+    action: 'Init',
+    source: context.sourceP,
+    prop: descP,
+    details: descP,
+    result: null,
+    error: warn ? false : true,
+    fields: null,
+    type: 'widgets',
+    prog_id: program.prog_id,
+  });
+  return null;
+};
+func.runtime.widgets.get_property_value = async function (context, fieldIdP, val, props) {
+  if (!val) return;
+  var value = fieldIdP in props ? props[fieldIdP] : typeof val.defaultValue === 'function' ? val?.defaultValue?.() : val?.defaultValue;
+  if (val.render === 'eventId') {
+    value = props?.[fieldIdP]?.event;
+  }
+
+  if (props[`xu-exp:${fieldIdP}`]) {
+    value = (await func.expression.get(context.SESSION_ID, props[`xu-exp:${fieldIdP}`], context.dsP, 'widget property')).result;
+  }
+
+  return func.common.get_cast_val(
+    context.SESSION_ID,
+    'widgets',
+    fieldIdP,
+    val.type,
+    value,
+    null,
+  );
+};
+func.runtime.widgets.get_fields_data = async function (context, fields, props) {
+  var data_obj = {};
+  var return_code = 1;
+  for await (const [key, val] of Object.entries(fields || {})) {
+    data_obj[key] = await func.runtime.widgets.get_property_value(context, key, val, props);
+    if (!data_obj[key] && val.mandatory) {
+      return_code = -1;
+      func.runtime.widgets.report_error(context, `${key} is a mandatory field.`);
+      break;
+    }
+  }
+  for await (const key of ['xu-bind']) {
+    data_obj[key] = await func.runtime.widgets.get_property_value(context, key, props?.[key], props);
+  }
+
+  return { code: return_code, data: data_obj };
+};
+func.runtime.widgets.get_resource_path = function (context, resource) {
+  if (context._session.worker_type === 'Dev') {
+    return `../../plugins/${context.plugin_name}/${resource}`;
+  }
+  const manifest_entry = context.plugin?.manifest?.[resource];
+  const dist_prefix = manifest_entry?.dist ? 'dist/' : '';
+  return `https://${context._session.domain}/plugins/${context.plugin_name}/${dist_prefix}${resource}?gtp_token=${context._session.gtp_token}&app_id=${context._session.app_id}`;
+};
+func.runtime.widgets.load_css_style = function (context) {
+  func.utils.load_css_on_demand(func.runtime.widgets.get_resource_path(context, 'style.css'));
+  return true;
+};
+func.runtime.widgets.get_resource = async function (context, resource) {
+  const manifest_entry = context.plugin?.manifest?.[resource];
+  const path = `${manifest_entry?.dist ? 'dist/' : ''}${resource}`;
+  return await func.utils.get_plugin_resource(context.SESSION_ID, context.plugin_name, path);
+};
+func.runtime.widgets.get_methods = async function (context) {
+  const index = await func.runtime.widgets.get_resource(context, 'index.mjs');
+  return index?.methods || {};
+};
+func.runtime.widgets.load_runtime_css = async function (context) {
+  if (!context.plugin?.manifest?.['runtime.mjs']?.dist || !context.plugin?.manifest?.['runtime.mjs']?.css) {
+    return false;
+  }
+  const plugin_runtime_css_url = await func.utils.get_plugin_npm_cdn(context.SESSION_ID, context.plugin_name, 'dist/runtime.css');
+  func.utils.load_css_on_demand(plugin_runtime_css_url);
+  return true;
+};
+func.runtime.widgets.build_params = function (context, $containerP, plugin_setup, api_utils, extra = {}) {
+  return {
+    SESSION_ID: context.SESSION_ID,
+    method: context.method,
+    _session: context._session,
+    dsP: context.dsP,
+    sourceP: context.sourceP,
+    propsP: context.propsP,
+    plugin_name: context.plugin_name,
+    $containerP,
+    plugin_setup,
+    report_error: function (descP, warn) {
+      return func.runtime.widgets.report_error(context, descP, warn);
+    },
+    call_plugin_api: async function (plugin_nameP, dataP) {
+      return await func.utils.call_plugin_api(context.SESSION_ID, plugin_nameP, dataP);
+    },
+    api_utils,
+    ...extra,
+  };
 };
 func.common.find_item_by_key = function (arr, key, val) {
   return _.find(arr, function (e) {
@@ -3761,13 +4084,13 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
                 });
               }
 
-              await func.UI.screen.refresh_screen(
+              await func.runtime.ui.refresh_screen({
                 SESSION_ID,
-                klona.klona(fields_changed), // _.cloneDeep(fields_changed),
-                datasource_changed[0],
-                datasource_changed[0], // refresh the current datasource only
-                value,
-              );
+                fields_changed_arr: klona.klona(fields_changed),
+                datasource_changed: datasource_changed[0],
+                fields_changed_datasource: datasource_changed[0],
+                watcher: value,
+              });
             }
 
             continue;
@@ -3876,14 +4199,22 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
         }
 
         // await func.UI.screen.refresh_xu_attributes(SESSION_ID, _.cloneDeep(fields_changed), null, null, findMin(datasource_changed), avoid_xu_for_refresh, trigger);
-        await func.UI.screen.refresh_xu_attributes(SESSION_ID, klona.klona(fields_changed), null, null, findMin(datasource_changed), avoid_xu_for_refresh, trigger);
+        await func.runtime.ui.refresh_xu_attributes({
+          SESSION_ID,
+          fields_arr: klona.klona(fields_changed),
+          jobNoP: null,
+          $elm_to_search: null,
+          dsSession_changed: findMin(datasource_changed),
+          avoid_xu_for_refresh,
+          trigger,
+        });
         // await removed from the below function cause to dead lock Mar 3 25
-        await func.UI.screen.refresh_screen(
+        await func.runtime.ui.refresh_screen({
           SESSION_ID,
-          klona.klona(fields_changed), // _.cloneDeep(fields_changed),
-          null,
-          datasource_changed[0], // refresh the current datasource only
-        );
+          fields_changed_arr: klona.klona(fields_changed),
+          datasource_changed: null,
+          fields_changed_datasource: datasource_changed[0],
+        });
       }
       // ///// REFRESH PARAMETERS IN
       // if (fields_changed.length) {
@@ -7311,7 +7642,20 @@ func.events.execute = async function (
       }
 
       const params_obj = await get_params_obj();
-      return await func.UI.screen.init(SESSION_ID, await get_prog_id(), $(containerP)?.data()?.xuData.screenId, _session.DS_GLB[dsSession], $calling_container, eventIdP, rowP, jobNoP, is_panel, params_obj, functionP, args.call_screen_propertiesP);
+      return await func.runtime.ui.init_screen({
+        SESSION_ID,
+        prog_id: await get_prog_id(),
+        sourceScreenP: $(containerP)?.data()?.xuData.screenId,
+        callingDataSource_objP: _session.DS_GLB[dsSession],
+        $callingContainerP: $calling_container,
+        triggerIdP: eventIdP,
+        rowIdP: rowP,
+        jobNoP,
+        is_panelP: is_panel,
+        parameters_obj_inP: params_obj,
+        source_functionP: functionP,
+        call_screen_propertiesP: args.call_screen_propertiesP,
+      });
     },
     call_modal: async function () {
       return await fx.Call_window();
@@ -8009,7 +8353,19 @@ func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
       let screen_ret = await func.utils.get_screen_obj(SESSION_ID, params_obj.prog);
 
       if (screen_ret) {
-        await func.UI.screen.init(SESSION_ID, params_obj.prog, null, null, $('#embed_' + SESSION_ID), null, null, null, null, null, 'pendingUrlEvent_embed');
+        await func.runtime.ui.init_screen({
+          SESSION_ID,
+          prog_id: params_obj.prog,
+          sourceScreenP: null,
+          callingDataSource_objP: null,
+          $callingContainerP: $('#embed_' + SESSION_ID),
+          triggerIdP: null,
+          rowIdP: null,
+          jobNoP: null,
+          is_panelP: null,
+          parameters_obj_inP: null,
+          source_functionP: 'pendingUrlEvent_embed',
+        });
       } else {
         console.error('Program not exist', params_obj.prog_id);
         func.UI.utils.progressScreen.show(SESSION_ID, 'Program not exist', null, true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/xuda-worker-bundle-min",
-  "version": "1.3.2432",
+  "version": "1.3.2433",
   "description": "xuda framework min",
   "main": "index.js",
   "scripts": {