@xuda.io/xuda-worker-bundle-min 1.3.2446 → 1.3.2448

package/index.js

@@ -500,6 +500,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];
@@ -627,11 +634,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') {
@@ -750,6 +758,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;

package/package.json

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