@xuda.io/runtime-bundle 1.0.1421 → 1.0.1423

package/js/xuda-runtime-bundle.js

@@ -23915,6 +23915,13 @@ func.runtime.session.create_state = function (SESSION_ID, options) {
   func.runtime.workers.ensure_registry(SESSION_ID);
   return SESSION_OBJ[SESSION_ID];
 };
+func.runtime.session.is_slim = function (SESSION_ID) {
+  const session = typeof SESSION_ID === 'undefined' || SESSION_ID === null ? null : SESSION_OBJ?.[SESSION_ID];
+  if (session && typeof session.SLIM_BUNDLE !== 'undefined') {
+    return !!session.SLIM_BUNDLE;
+  }
+  return !!glb.SLIM_BUNDLE;
+};
 func.runtime.session.set_default_value = function (_session, key, value) {
   _session[key] = value || func.runtime.env.get_default_session_value(key);
   return _session[key];
@@ -24042,11 +24049,12 @@ func.runtime.render.get_root_data_system = function (SESSION_ID) {
 func.runtime.render.resolve_xu_for_source = async function (SESSION_ID, dsSessionP, value) {
   let arr = value;
   let reference_source_obj;
+  const normalized_reference = typeof value === 'string' && value.startsWith('@') ? value.substring(1) : value;
   const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSessionP);
-  let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', value);
+  let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', normalized_reference);
 
-  if (view_field_obj) {
-    reference_source_obj = await func.datasource.get_value(SESSION_ID, value, dsSessionP);
+  if (view_field_obj || normalized_reference !== value) {
+    reference_source_obj = await func.datasource.get_value(SESSION_ID, normalized_reference, dsSessionP);
     arr = reference_source_obj?.ret?.value;
   } else {
     if (typeof value === 'string') {
@@ -24165,6 +24173,135 @@ func.runtime.bind.build_datasource_changes = function (dsSessionP, currentRecord
     },
   };
 };
+func.runtime.bind.get_native_adapter = function () {
+  const has_explicit_value = function (elm) {
+    return !!elm?.hasAttribute?.('value');
+  };
+  const get_listener_event = function (elm) {
+    const tag_name = elm?.tagName?.toLowerCase?.();
+    const type = (elm?.type || '').toLowerCase();
+
+    if (tag_name === 'select' || ['checkbox', 'radio'].includes(type)) {
+      return 'change';
+    }
+    return 'input';
+  };
+
+  return {
+    getter: function (elm) {
+      if (!elm) {
+        return undefined;
+      }
+
+      const tag_name = elm?.tagName?.toLowerCase?.();
+      const type = (elm?.type || '').toLowerCase();
+
+      if (tag_name === 'select' && elm.multiple) {
+        return Array.from(elm.options || [])
+          .filter(function (option) {
+            return option.selected;
+          })
+          .map(function (option) {
+            return option.value;
+          });
+      }
+
+      if (type === 'checkbox') {
+        return has_explicit_value(elm) ? elm.value : !!elm.checked;
+      }
+
+      if (type === 'radio') {
+        return elm.value;
+      }
+
+      return typeof elm.value !== 'undefined' ? elm.value : undefined;
+    },
+    setter: function (elm, value) {
+      if (!elm) {
+        return false;
+      }
+
+      const tag_name = elm?.tagName?.toLowerCase?.();
+      const type = (elm?.type || '').toLowerCase();
+
+      if (tag_name === 'select' && elm.multiple) {
+        const selected_values = Array.isArray(value)
+          ? value.map(function (item) {
+            return String(item);
+          })
+          : [String(value)];
+        Array.from(elm.options || []).forEach(function (option) {
+          option.selected = selected_values.includes(String(option.value));
+        });
+        return true;
+      }
+
+      if (type === 'checkbox' || type === 'radio') {
+        return true;
+      }
+
+      if (typeof elm.value !== 'undefined') {
+        elm.value = value === null || typeof value === 'undefined' ? '' : String(value);
+      }
+      return true;
+    },
+    listener: function (elm, handler) {
+      if (!elm?.addEventListener || typeof handler !== 'function') {
+        return false;
+      }
+
+      const event_name = get_listener_event(elm);
+      const listener_key = '__xuda_native_bind_listener_' + event_name;
+      if (elm[listener_key]) {
+        elm.removeEventListener(event_name, elm[listener_key]);
+      }
+      elm.addEventListener(event_name, handler);
+      elm[listener_key] = handler;
+      return true;
+    },
+  };
+};
+func.runtime.bind.is_valid_adapter = function (adapter) {
+  return !!(
+    adapter &&
+    typeof adapter.getter === 'function' &&
+    typeof adapter.setter === 'function' &&
+    typeof adapter.listener === 'function'
+  );
+};
+func.runtime.bind.get_adapter = function (SESSION_ID) {
+  const native_adapter = func.runtime.bind.get_native_adapter();
+  if (func.runtime.session.is_slim(SESSION_ID)) {
+    return native_adapter;
+  }
+
+  const plugin_bind = UI_FRAMEWORK_PLUGIN?.bind;
+  if (!plugin_bind) {
+    return native_adapter;
+  }
+
+  if (func.runtime.bind.is_valid_adapter(plugin_bind)) {
+    return plugin_bind;
+  }
+
+  if (typeof plugin_bind === 'function') {
+    try {
+      const bind_instance = new plugin_bind();
+      if (func.runtime.bind.is_valid_adapter(bind_instance)) {
+        return bind_instance;
+      }
+    } catch (error) {}
+
+    try {
+      const bind_factory = plugin_bind();
+      if (func.runtime.bind.is_valid_adapter(bind_factory)) {
+        return bind_factory;
+      }
+    } catch (error) {}
+  }
+
+  return native_adapter;
+};
 func.runtime.bind.resolve_field = async function (SESSION_ID, prog_id, dsSessionP, field_id, iterate_info) {
   let _prog_id = prog_id;
   let _dsP = dsSessionP;
@@ -27937,7 +28074,10 @@ func.runtime.ui.find_in_root = function (SESSION_ID, selector) {
 };
 func.runtime.ui.get_root_tag_name = function () {
   let root_tag_name = 'div';
-  if (typeof glb.SLIM_BUNDLE === 'undefined' && !glb.SLIM_BUNDLE) {
+  if (!func.runtime.session.is_slim()) {
+    if (typeof UI_FRAMEWORK_PLUGIN?.core !== 'function') {
+      return root_tag_name;
+    }
     const ui_plugin_core = new UI_FRAMEWORK_PLUGIN.core();
     root_tag_name = ui_plugin_core?.rootTagName() || root_tag_name;
   }
@@ -31764,6 +31904,12 @@ func.runtime.ui.close_modal_session = async function (SESSION_ID, modal_id) {
 func.runtime.ui.render_screen_type = async function (options) {
   const $div_content = func.runtime.ui.get_children(options.$div);
   func.runtime.ui.sync_child_parent_container(options.$div);
+  const assert_framework_screen_supported = function (screen_type) {
+    if (!func.runtime.session.is_slim(options.SESSION_ID)) {
+      return;
+    }
+    throw new Error('Slim mode does not support "' + screen_type + '" screens without a UI framework plugin');
+  };
 
   let $ret = options.$div;
   let $nav = func.runtime.ui.get_nav(options.SESSION_ID);
@@ -31771,6 +31917,7 @@ func.runtime.ui.render_screen_type = async function (options) {
 
   switch (options.paramsP.screen_type) {
     case 'modal': {
+      assert_framework_screen_supported('modal');
       params = func.runtime.ui.build_modal_params(options.paramsP, options.$div, options.$container, options.close_modal);
       const modal_id = params.modal_id;
       func.runtime.ui.set_modal_params(options.SESSION_ID, modal_id, params);
@@ -31787,6 +31934,7 @@ func.runtime.ui.render_screen_type = async function (options) {
     }
 
     case 'popover': {
+      assert_framework_screen_supported('popover');
       const xu_popover_controller = func.UI.component.create_app_popover_component(options.SESSION_ID);
       params = func.runtime.ui.build_popover_params(options.paramsP, options.$div, options.$container);
 
@@ -31801,6 +31949,7 @@ func.runtime.ui.render_screen_type = async function (options) {
     }
 
     case 'page': {
+      assert_framework_screen_supported('page');
       const nav = func.runtime.ui.get_first_node($nav);
 
       params = func.runtime.ui.build_page_params(options.SESSION_ID, options.paramsP, $div_content, options.$container, nav);
@@ -35377,8 +35526,8 @@ func.runtime.render.get_xu_for_iterators = function ($elm) {
   return {
     iterator_key: custom_iterator_key || '_FOR_KEY',
     iterator_val: custom_iterator_val || '_FOR_VAL',
-    is_key_dynamic_field: !custom_iterator_key,
-    is_val_dynamic_field: !custom_iterator_val,
+    is_key_dynamic_field: true,
+    is_val_dynamic_field: true,
   };
 };
 func.runtime.render.attach_iterate_info_to_children = function ($divP, iterate_info) {
@@ -36404,7 +36553,7 @@ func.runtime.render.handle_xu_bind = async function (options) {
     return {};
   }
 
-  const bind = new UI_FRAMEWORK_PLUGIN.bind();
+  const bind = func.runtime.bind.get_adapter(options.SESSION_ID);
   const field_changed = async function () {
     const _ds = SESSION_OBJ[options.SESSION_ID].DS_GLB[_dsP];
     const field_type = func.runtime.bind.get_field_type(field_prop);
@@ -44844,13 +44993,22 @@ func.index.call_worker = async function (SESSION_ID, obj, params, promiseP) {
 };
 
 func.index.init_SCREEN_BLOCKER = async function (SESSION_ID) {
+  const get_loader = async function () {
+    if (func.runtime.session.is_slim(SESSION_ID) || typeof UI_FRAMEWORK_PLUGIN?.loader !== 'function') {
+      return {
+        dismiss: function () {},
+      };
+    }
+    return await UI_FRAMEWORK_PLUGIN.loader(LOADER_TEXT);
+  };
+
   setInterval(async function () {
     if (glb.CURRENT_APP_LOADING || (!LOADER_ACTIVE && xu_isEmpty(SCREEN_BLOCKER_OBJ))) {
       return;
     }
     glb.CURRENT_APP_LOADING = 1;
 
-    const loader = await UI_FRAMEWORK_PLUGIN.loader(LOADER_TEXT);
+    const loader = await get_loader();
 
     glb.CURRENT_APP_LOADING = loader;