@xuda.io/xuda-worker-bundle-min 1.3.2435 → 1.3.2436

package/index.js

@@ -10,6 +10,15 @@ var func = {};
 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 = {};
@@ -23,6 +32,855 @@ glb.PROTECTED_VARS = ['_NULL', '_THIS', '_FOR_KEY', '_FOR_VAL', '_ROWNO', '_ROWI
 // glb.newRecord = 999999;
 
 func.common = {};
+func.runtime.platform = {
+  has_window: function () {
+    return typeof window !== 'undefined';
+  },
+  has_document: function () {
+    return typeof document !== 'undefined';
+  },
+  get_window: function () {
+    if (func.runtime.platform.has_window()) {
+      return window;
+    }
+    return null;
+  },
+  get_document: function () {
+    if (func.runtime.platform.has_document()) {
+      return document;
+    }
+    return null;
+  },
+  get_location: function () {
+    const win = func.runtime.platform.get_window();
+    return win?.location || null;
+  },
+  get_navigator: function () {
+    const win = func.runtime.platform.get_window();
+    if (win?.navigator) {
+      return win.navigator;
+    }
+    if (typeof navigator !== 'undefined') {
+      return navigator;
+    }
+    return null;
+  },
+  is_html_element: function (value) {
+    if (typeof HTMLElement === 'undefined') {
+      return false;
+    }
+    return value instanceof HTMLElement;
+  },
+  get_storage: function (type) {
+    const win = func.runtime.platform.get_window();
+    try {
+      if (!win) {
+        return null;
+      }
+      if (type === 'session') {
+        return win.sessionStorage || null;
+      }
+      return win.localStorage || null;
+    } catch (error) {
+      return null;
+    }
+  },
+  get_storage_item: function (key, type) {
+    const storage = func.runtime.platform.get_storage(type);
+    if (!storage) {
+      return null;
+    }
+    try {
+      return storage.getItem(key);
+    } catch (error) {
+      return null;
+    }
+  },
+  set_storage_item: function (key, value, type) {
+    const storage = func.runtime.platform.get_storage(type);
+    if (!storage) {
+      return false;
+    }
+    try {
+      storage.setItem(key, value);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  },
+  get_url_href: function () {
+    return func.runtime.platform.get_location()?.href || '';
+  },
+  get_url_search: function () {
+    return func.runtime.platform.get_location()?.search || '';
+  },
+  get_url_hash: function () {
+    return func.runtime.platform.get_location()?.hash || '';
+  },
+  get_host: function () {
+    return func.runtime.platform.get_location()?.host || '';
+  },
+  get_hostname: function () {
+    return func.runtime.platform.get_location()?.hostname || '';
+  },
+  get_device_uuid: function () {
+    const win = func.runtime.platform.get_window();
+    return win?.device?.uuid || null;
+  },
+  get_device_name: function () {
+    const win = func.runtime.platform.get_window();
+    return win?.device?.name || null;
+  },
+  get_inner_size: function () {
+    const win = func.runtime.platform.get_window();
+    return {
+      width: win?.innerWidth || 0,
+      height: win?.innerHeight || 0,
+    };
+  },
+  add_window_listener: function (name, handler) {
+    const win = func.runtime.platform.get_window();
+    if (!win?.addEventListener) {
+      return false;
+    }
+    win.addEventListener(name, handler);
+    return true;
+  },
+  dispatch_body_event: function (event) {
+    const doc = func.runtime.platform.get_document();
+    if (!doc?.body?.dispatchEvent) {
+      return false;
+    }
+    doc.body.dispatchEvent(event);
+    return true;
+  },
+  reload_top_window: function () {
+    const win = func.runtime.platform.get_window();
+    if (!win?.top?.location?.reload) {
+      return false;
+    }
+    win.top.location.reload();
+    return true;
+  },
+  get_service_worker: function () {
+    const nav = func.runtime.platform.get_navigator();
+    return nav?.serviceWorker || null;
+  },
+  has_service_worker: function () {
+    return !!func.runtime.platform.get_service_worker();
+  },
+  register_service_worker: function (script_url) {
+    const service_worker = func.runtime.platform.get_service_worker();
+    if (!service_worker?.register) {
+      return Promise.reject(new Error('serviceWorker is not available'));
+    }
+    return service_worker.register(script_url);
+  },
+  add_service_worker_listener: function (name, handler) {
+    const service_worker = func.runtime.platform.get_service_worker();
+    if (!service_worker?.addEventListener) {
+      return false;
+    }
+    service_worker.addEventListener(name, handler);
+    return true;
+  },
+};
+func.runtime.env = {
+  get_url_params: function () {
+    const search = func.runtime.platform.get_url_search();
+    return new URLSearchParams(search);
+  },
+  get_url_parameters_object: function () {
+    const search_params = func.runtime.env.get_url_params();
+    const parameters = {};
+    for (const [key, value] of search_params.entries()) {
+      parameters[key] = value;
+    }
+    return parameters;
+  },
+  get_default_session_value: function (key) {
+    switch (key) {
+      case 'domain':
+        return func.runtime.platform.get_host();
+      case 'engine_mode':
+        return 'miniapp';
+      case 'app_id':
+        return 'unknown';
+      default:
+        return null;
+    }
+  },
+};
+func.runtime.session.create_tab_id = function () {
+  const session_storage = func.runtime.platform.get_storage('session');
+  const local_storage = func.runtime.platform.get_storage('local');
+  var page_tab_id = session_storage?.getItem('tabID');
+  if (page_tab_id == null) {
+    var local_tab_id = local_storage?.getItem('tabID');
+    page_tab_id = local_tab_id == null ? 1 : Number(local_tab_id) + 1;
+    func.runtime.platform.set_storage_item('tabID', page_tab_id, 'local');
+    func.runtime.platform.set_storage_item('tabID', page_tab_id, 'session');
+  }
+  return page_tab_id;
+};
+func.runtime.session.get_fingerprint = function (components, instance_id) {
+  const device_uuid = func.runtime.platform.get_device_uuid();
+  if (func.utils.get_device() && device_uuid) {
+    if (instance_id) {
+      return instance_id + device_uuid;
+    }
+    return device_uuid;
+  }
+  const fingerprint_id = Fingerprint2.x64hash128(
+    components
+      .map(function (pair) {
+        return pair.value;
+      })
+      .join(),
+    31,
+  );
+
+  if (instance_id) {
+    return instance_id + fingerprint_id + func.runtime.session.create_tab_id();
+  }
+  return fingerprint_id;
+};
+func.runtime.session.create_state = function (SESSION_ID, options) {
+  const runtime_host = func.runtime.platform.get_host();
+  SESSION_OBJ[SESSION_ID] = {
+    JOB_NO: 1000,
+    opt: options.opt,
+    root_element: options.root_element,
+    worker_type: options.worker_type,
+    api_callback: options.api_callback,
+    CODE_BUNDLE: options.code_bundle,
+    SLIM_BUNDLE: options.slim_bundle,
+    WORKER_OBJ: {
+      jobs: [],
+      num: 1000,
+      stat: null,
+    },
+    DS_GLB: {},
+    SYS_GLOBAL_OBJ_FIREBASE_AUTH_INFO: {
+      token: '',
+      first_name: '',
+      last_name: '',
+      email: '',
+      user_id: '',
+      picture: '',
+      verified_email: '',
+      locale: '',
+      error_code: '',
+      error_msg: '',
+    },
+    SYS_GLOBAL_OBJ_CLIENT_INFO: {
+      fingerprint: '',
+      device: '',
+      user_agent: '',
+      browser_version: '',
+      browser_name: '',
+      engine_version: '',
+      client_ip: '',
+      engine_name: '',
+      os_name: '',
+      os_version: '',
+      device_model: '',
+      device_vendor: '',
+      device_type: '',
+      screen_current_resolution_x: '',
+      screen_current_resolution_y: '',
+      screen_available_resolution_x: '',
+      screen_available_resolution_y: '',
+      language: '',
+      time_zone: '',
+      cpu_architecture: '',
+      uuid: '',
+    },
+    PUSH_NOTIFICATION_GRANTED: null,
+    FIREBASE_TOKEN_ID: null,
+    USR_OBJ: {},
+    debug_js: null,
+    DS_UI_EVENTS_GLB: {},
+    host: runtime_host,
+    req_id: 0,
+    build_info: {},
+    CACHE_REQ: {},
+    url_params: {
+      ...func.common.getParametersFromUrl(),
+      ...options.url_params,
+    },
+  };
+  func.runtime.workers.ensure_registry(SESSION_ID);
+  return SESSION_OBJ[SESSION_ID];
+};
+func.runtime.session.set_default_value = function (_session, key, value) {
+  _session[key] = value || func.runtime.env.get_default_session_value(key);
+  return _session[key];
+};
+func.runtime.session.populate_client_info = function (_session, components) {
+  const _client_info = _session.SYS_GLOBAL_OBJ_CLIENT_INFO;
+  const platform = func.runtime.platform;
+  const { engine_mode } = _session;
+
+  _client_info.fingerprint = func.runtime.session.get_fingerprint(components);
+
+  if (engine_mode === 'live_preview') {
+    const inner_size = platform.get_inner_size();
+    _client_info.screen_current_resolution_x = inner_size.width;
+    _client_info.screen_current_resolution_y = inner_size.height;
+    _client_info.screen_available_resolution_x = inner_size.width;
+    _client_info.screen_available_resolution_y = inner_size.height;
+  } else {
+    _client_info.screen_current_resolution_x = components[6].value[0];
+    _client_info.screen_current_resolution_y = components[6].value[1];
+    _client_info.screen_available_resolution_x = components[7].value[0];
+    _client_info.screen_available_resolution_y = components[7].value[1];
+  }
+
+  const client = new ClientJS();
+  _client_info.device = func.utils.get_device();
+
+  const browser_data = client.getBrowserData();
+  _client_info.user_agent = browser_data.ua;
+  _client_info.browser_version = browser_data.browser.name;
+  _client_info.browser_name = browser_data.browser.version;
+  _client_info.engine_version = browser_data.engine.name;
+  _client_info.engine_name = browser_data.engine.version;
+  _client_info.os_name = browser_data.os.name;
+  _client_info.os_version = browser_data.os.version;
+  _client_info.device_model = browser_data.device.name;
+  _client_info.device_vendor = browser_data.device.name;
+  _client_info.device_type = browser_data.device.name;
+  _client_info.language = client.getLanguage();
+  _client_info.time_zone = client.getTimeZone();
+  _client_info.cpu_architecture = browser_data.cpu.architecture;
+
+  if (['android', 'ios', 'windows', 'macos', 'linux', 'live_preview'].includes(engine_mode) && func.utils.get_device()) {
+    _client_info.uuid = platform.get_device_uuid();
+    const device_name = platform.get_device_name();
+    if (device_name) {
+      _client_info.device_name = device_name;
+    }
+  }
+  return _client_info;
+};
+func.runtime.workers.ensure_registry = function (SESSION_ID) {
+  if (!WEB_WORKER[SESSION_ID]) {
+    WEB_WORKER[SESSION_ID] = {};
+  }
+  return WEB_WORKER[SESSION_ID];
+};
+func.runtime.workers.get_registry_entry = function (SESSION_ID, worker_id) {
+  return func.runtime.workers.ensure_registry(SESSION_ID)?.[worker_id] || null;
+};
+func.runtime.workers.set_registry_entry = function (SESSION_ID, worker_id, entry) {
+  const worker_registry = func.runtime.workers.ensure_registry(SESSION_ID);
+  worker_registry[worker_id] = entry;
+  return worker_registry[worker_id];
+};
+func.runtime.workers.build_worker_name = function (glb_worker_type, session, prog_obj, worker_id, build_id) {
+  return (
+    `${typeof session.SLIM_BUNDLE === 'undefined' || !session.SLIM_BUNDLE ? '' : 'Slim '}${prog_obj.menuName} worker` +
+    ' ' +
+    glb_worker_type +
+    ': #' +
+    worker_id.toString() +
+    ' ' +
+    (build_id || '') +
+    ' ' +
+    session.domain
+  );
+};
+func.runtime.workers.is_server_transport = function (session) {
+  return !!(RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED && (!session.opt.app_computing_mode || session.opt.app_computing_mode === 'server'));
+};
+func.runtime.workers.send_message = function (SESSION_ID, worker_id, session, msg, process_pid) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry?.worker) {
+    return false;
+  }
+
+  if (func.runtime.workers.is_server_transport(session)) {
+    if (process_pid) {
+      msg.process_pid = process_pid;
+    }
+    registry_entry.worker.emit('message', msg);
+    return true;
+  }
+
+  registry_entry.worker.postMessage(msg);
+  return true;
+};
+func.runtime.workers.set_promise = function (SESSION_ID, worker_id, promise_queue_id, value) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry) {
+    return null;
+  }
+  registry_entry.promise_queue[promise_queue_id] = value;
+  return registry_entry.promise_queue[promise_queue_id];
+};
+func.runtime.workers.get_promise = function (SESSION_ID, worker_id, promise_queue_id) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry) {
+    return null;
+  }
+  return registry_entry.promise_queue[promise_queue_id];
+};
+func.runtime.workers.delete_promise = function (SESSION_ID, worker_id, promise_queue_id) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry?.promise_queue) {
+    return false;
+  }
+  delete registry_entry.promise_queue[promise_queue_id];
+  return true;
+};
+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);
+
+  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());
+    }
+  }
+
+  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;
+  }
+
+  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}`];
+          }
+        }
+        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;
+
+  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`;
+  }
+
+  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');
+
+  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.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 (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;
+  }
+
+  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.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.resources.get_plugin_manifest_entry = function (_session, plugin_name) {
+  return APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name] || null;
+};
+func.runtime.resources.get_plugin_module_path = function (plugin, resource) {
+  const manifest_entry = plugin?.manifest?.[resource];
+  return `${manifest_entry?.dist ? 'dist/' : ''}${resource}`;
+};
+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) {
     return e.data[key] === val;
@@ -411,19 +1269,10 @@ func.common.db = async function (SESSION_ID, serviceP, dataP, opt = {}, dsSessio
 };
 
 func.common.getJsonFromUrl = function () {
-  const queryString = window.location.search;
-  const urlParams = new URLSearchParams(queryString);
-  return urlParams;
+  return func.runtime.env.get_url_params();
 };
 func.common.getParametersFromUrl = function () {
-  const searchParams = new URLSearchParams(window.location.search);
-  const parameters = {};
-
-  for (const [key, value] of searchParams.entries()) {
-    parameters[key] = value;
-  }
-
-  return parameters;
+  return func.runtime.env.get_url_parameters_object();
 };
 
 func.common.getObjectFromUrl = function (url, element_attributes_obj, embed_params_obj) {
@@ -3235,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;
@@ -3345,28 +4194,27 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
       }
       ///// REFRESH SCREEN
       if (fields_changed.length) {
-        // Push changes into reactive signals (V2 reactive system)
-        if (func.reactive?.bridge?.interceptUpdate) {
-          func.reactive.bridge.interceptUpdate(SESSION_ID, datasource_changes, fields_changed, datasource_changed);
-        }
-
         function findMin(arr) {
           return Math.min(...arr.map(Number));
         }
 
-        // In reactive mode, effects handle DOM updates automatically via the scheduler.
-        // Skip the legacy scan-based refresh which does O(n) element scanning.
-        if (!_session._reactiveMode) {
-          // 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 removed from the below function cause to dead lock Mar 3 25
-          await func.UI.screen.refresh_screen(
-            SESSION_ID,
-            klona.klona(fields_changed), // _.cloneDeep(fields_changed),
-            null,
-            datasource_changed[0], // refresh the current datasource only
-          );
-        }
+        // await func.UI.screen.refresh_xu_attributes(SESSION_ID, _.cloneDeep(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.runtime.ui.refresh_screen({
+          SESSION_ID,
+          fields_changed_arr: klona.klona(fields_changed),
+          datasource_changed: null,
+          fields_changed_datasource: datasource_changed[0],
+        });
       }
       // ///// REFRESH PARAMETERS IN
       // if (fields_changed.length) {
@@ -6794,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();
@@ -7492,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.2435",
+  "version": "1.3.2436",
   "description": "xuda framework min",
   "main": "index.js",
   "scripts": {