@xuda.io/runtime-bundle 1.0.1422 → 1.0.1424

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];
@@ -24166,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;
@@ -27938,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;
   }
@@ -31765,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);
@@ -31772,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);
@@ -31788,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);
 
@@ -31802,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);
@@ -36405,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);
@@ -41365,6 +41513,25 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
 
       // var split = [];
       var var_Arr = [];
+      const get_iterate_value_ret = function (fieldIdP) {
+        if (!iterate_info || (iterate_info.iterator_key !== fieldIdP && iterate_info.iterator_val !== fieldIdP)) {
+          return null;
+        }
+
+        const iter_value = iterate_info.iterator_key === fieldIdP ? iterate_info._key : iterate_info._val;
+        const iter_type = typeof iter_value !== 'undefined' ? {}.toString.call(iter_value).match(/\s([a-zA-Z]+)/)[1].toLowerCase() : 'string';
+
+        return {
+          ret: {
+            value: iter_value,
+            type: iter_type,
+            prop: ['array', 'object'].includes(iter_type) ? iter_value : null,
+          },
+          fieldIdP,
+          currentRecordId: rowIdP,
+          found: typeof iter_value !== 'undefined',
+        };
+      };
       const split = func.expression.parse(ret) || [];
       // console.log(valP, split);
       const split_entries = Object.entries(split);
@@ -41461,7 +41628,7 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
           } // put default
           fields[val.fieldId] = var_Arr[key].value;
 
-          const ret = await func.datasource.get_value(SESSION_ID, val.fieldId, dsSessionP, rowIdP); // find field in dataSources
+          const ret = get_iterate_value_ret(val.fieldId) || (await func.datasource.get_value(SESSION_ID, val.fieldId, dsSessionP, rowIdP)); // find field in dataSources
 
           await replace_value_in_string(ret.ret, ret.fieldIdP);
         }
@@ -44845,13 +45012,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;