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

package/index.js

@@ -10,15 +10,6 @@ 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 = {};
@@ -32,855 +23,6 @@ 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;
@@ -1269,10 +411,19 @@ func.common.db = async function (SESSION_ID, serviceP, dataP, opt = {}, dsSessio
 };
 
 func.common.getJsonFromUrl = function () {
-  return func.runtime.env.get_url_params();
+  const queryString = window.location.search;
+  const urlParams = new URLSearchParams(queryString);
+  return urlParams;
 };
 func.common.getParametersFromUrl = function () {
-  return func.runtime.env.get_url_parameters_object();
+  const searchParams = new URLSearchParams(window.location.search);
+  const parameters = {};
+
+  for (const [key, value] of searchParams.entries()) {
+    parameters[key] = value;
+  }
+
+  return parameters;
 };
 
 func.common.getObjectFromUrl = function (url, element_attributes_obj, embed_params_obj) {
@@ -4084,13 +3235,13 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
                 });
               }
 
-              await func.runtime.ui.refresh_screen({
+              await func.UI.screen.refresh_screen(
                 SESSION_ID,
-                fields_changed_arr: klona.klona(fields_changed),
-                datasource_changed: datasource_changed[0],
-                fields_changed_datasource: datasource_changed[0],
-                watcher: value,
-              });
+                klona.klona(fields_changed), // _.cloneDeep(fields_changed),
+                datasource_changed[0],
+                datasource_changed[0], // refresh the current datasource only
+                value,
+              );
             }
 
             continue;
@@ -4194,27 +3345,28 @@ 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));
         }
 
-        // 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],
-        });
+        // 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
+          );
+        }
       }
       // ///// REFRESH PARAMETERS IN
       // if (fields_changed.length) {
@@ -7642,20 +6794,7 @@ func.events.execute = async function (
       }
 
       const params_obj = await get_params_obj();
-      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,
-      });
+      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);
     },
     call_modal: async function () {
       return await fx.Call_window();
@@ -8353,19 +7492,7 @@ 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.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',
-        });
+        await func.UI.screen.init(SESSION_ID, params_obj.prog, null, null, $('#embed_' + SESSION_ID), null, null, null, null, null, '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.2433",
+  "version": "1.3.2435",
   "description": "xuda framework min",
   "main": "index.js",
   "scripts": {