@xuda.io/xuda-worker-bundle 1.3.2622 → 1.3.2624

package/index.js

@@ -2259,6 +2259,395 @@ glb.run_xu_before = [
 glb.run_xu_after = ['xu-bind', 'xu-class', 'xu-script', 'xu-ui-plugin', 'xu-ref'];
 glb.attr_abbreviations_arr = ['xu-click', 'xu-dblclick', 'xu-contextmenu', 'xu-focus', 'xu-keyup', 'xu-change', 'xu-blur', 'xu-init'];
 glb.solid_attributes = ['disabled'];
+ // ── Headless/SSR DOM adapter ──
+// Provides a no-op / in-memory implementation of func.runtime.ui
+// for environments without a DOM (Node.js, workers, SSR).
+// Elements are plain objects; metadata lives in _meta_store.
+
+func.runtime = func.runtime || {};
+func.runtime.ui = func.runtime.ui || {};
+func.runtime.render = func.runtime.render || {};
+func.runtime.widgets = func.runtime.widgets || {};
+func.runtime.ui.ui_id_hash_cache = func.runtime.ui.ui_id_hash_cache || new Map();
+func.runtime.ui.node_snapshot_cache = func.runtime.ui.node_snapshot_cache || new WeakMap();
+func.runtime.ui.node_child_items_cache = func.runtime.ui.node_child_items_cache || new WeakMap();
+func.runtime.ui.node_children_by_id_cache = func.runtime.ui.node_children_by_id_cache || new WeakMap();
+
+// ── Metadata store (shared with browser adapter) ──
+func.runtime.ui._meta_store = func.runtime.ui._meta_store || {};
+func.runtime.ui._element_id_to_xu_ui_id = func.runtime.ui._element_id_to_xu_ui_id || {};
+
+func.runtime.ui.set_meta = function (xu_ui_id, key, value) {
+  if (!xu_ui_id) return;
+  if (!func.runtime.ui._meta_store[xu_ui_id]) {
+    func.runtime.ui._meta_store[xu_ui_id] = {};
+  }
+  func.runtime.ui._meta_store[xu_ui_id][key] = value;
+};
+func.runtime.ui.get_meta = function (xu_ui_id, key) {
+  const entry = func.runtime.ui._meta_store[xu_ui_id];
+  if (!entry) return undefined;
+  return key ? entry[key] : entry;
+};
+func.runtime.ui.delete_meta = function (xu_ui_id) {
+  delete func.runtime.ui._meta_store[xu_ui_id];
+  for (const id in func.runtime.ui._element_id_to_xu_ui_id) {
+    if (func.runtime.ui._element_id_to_xu_ui_id[id] === xu_ui_id) {
+      delete func.runtime.ui._element_id_to_xu_ui_id[id];
+    }
+  }
+};
+func.runtime.ui.register_element_id = function (element_id, xu_ui_id) {
+  if (element_id && xu_ui_id) {
+    func.runtime.ui._element_id_to_xu_ui_id[element_id] = xu_ui_id;
+  }
+};
+func.runtime.ui.get_meta_by_element_id = function (element_id) {
+  if (!element_id) return undefined;
+  const clean_id = element_id.startsWith('#') ? element_id.substring(1) : element_id;
+  const xu_ui_id = func.runtime.ui._element_id_to_xu_ui_id[clean_id];
+  if (xu_ui_id) {
+    return func.runtime.ui._meta_store[xu_ui_id];
+  }
+  return undefined;
+};
+func.runtime.ui.find_element_by_id = function () {
+  return null;
+};
+func.runtime.ui.get_session_root = function () {
+  return null;
+};
+func.runtime.ui.clear_screen_blockers = function () {
+  // no-op in headless
+};
+
+// ── Virtual element representation ──
+var _next_id = 1;
+function create_virtual_element(tag, attrs) {
+  return {
+    _v_id: _next_id++,
+    tag: tag || 'div',
+    attrs: attrs || {},
+    children: [],
+    parent: null,
+    style: {},
+    classList: [],
+    textContent: '',
+    innerHTML: '',
+    hidden: false,
+    _data: {},
+  };
+}
+
+// ── Core adapter methods ──
+func.runtime.ui.as_jquery = function (target) {
+  if (!target) return { length: 0, data: function () { return {}; }, toArray: function () { return []; }, attr: function () { return undefined; } };
+  if (target._v_id) return target;
+  return target;
+};
+func.runtime.ui.get_first_node = function (target) {
+  if (!target) return null;
+  if (target._v_id) return target;
+  if (Array.isArray(target)) return target[0] || null;
+  return null;
+};
+func.runtime.ui.get_data = function (target) {
+  if (!target) return {};
+  if (target._v_id) {
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) {
+      const meta = func.runtime.ui._meta_store[xu_ui_id];
+      if (meta) return meta;
+    }
+    return target._data;
+  }
+  return {};
+};
+func.runtime.ui.get_parent = function (target) {
+  if (target?._v_id) return target.parent;
+  return null;
+};
+func.runtime.ui.get_children = function (target) {
+  if (target?._v_id) return target.children.slice();
+  return [];
+};
+func.runtime.ui.find_by_selector = function () {
+  return { length: 0, toArray: function () { return []; } };
+};
+func.runtime.ui.insert_before = function ($element) { return $element; };
+func.runtime.ui.insert_after = function ($element) { return $element; };
+func.runtime.ui.has_selector = function () { return false; };
+func.runtime.ui.append_html = function (target) { return target; };
+func.runtime.ui.set_style = function (target, prop, value) {
+  if (target?._v_id) target.style[prop] = value;
+  return target;
+};
+func.runtime.ui.get_attr = function (target, key) {
+  if (target?._v_id) return target.attrs[key];
+  return undefined;
+};
+func.runtime.ui.set_attr = function (target, key, value) {
+  if (target?._v_id) target.attrs[key] = value;
+  return target;
+};
+func.runtime.ui.set_data = function (target, key, value) {
+  if (target?._v_id) {
+    target._data[key] = value;
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) {
+      func.runtime.ui.set_meta(xu_ui_id, key, value);
+    }
+  }
+  return target;
+};
+func.runtime.ui.clear_data = function (target) {
+  if (target?._v_id) {
+    target._data = {};
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) func.runtime.ui.delete_meta(xu_ui_id);
+  }
+  return target;
+};
+func.runtime.ui.add_class = function (target, cls) {
+  if (target?._v_id && cls && !target.classList.includes(cls)) target.classList.push(cls);
+  return target;
+};
+func.runtime.ui.remove_class = function (target, cls) {
+  if (target?._v_id) {
+    const idx = target.classList.indexOf(cls);
+    if (idx !== -1) target.classList.splice(idx, 1);
+  }
+  return target;
+};
+func.runtime.ui.set_html = function (target, value) {
+  if (target?._v_id) target.innerHTML = value;
+  return target;
+};
+func.runtime.ui.set_text = function (target, value) {
+  if (target?._v_id) target.textContent = value;
+  return target;
+};
+func.runtime.ui.show = function (target) {
+  if (target?._v_id) target.hidden = false;
+  return target;
+};
+func.runtime.ui.hide = function (target) {
+  if (target?._v_id) target.hidden = true;
+  return target;
+};
+func.runtime.ui.append = function ($target, $element) {
+  if ($target?._v_id && $element?._v_id) {
+    $target.children.push($element);
+    $element.parent = $target;
+  }
+  return $element;
+};
+func.runtime.ui.append_to = function ($element, $target) {
+  return func.runtime.ui.append($target, $element);
+};
+func.runtime.ui.empty = function (target) {
+  if (target?._v_id) target.children = [];
+  return target;
+};
+func.runtime.ui.remove = function (target) {
+  if (target?._v_id) {
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) func.runtime.ui.delete_meta(xu_ui_id);
+    if (target.parent?._v_id) {
+      const idx = target.parent.children.indexOf(target);
+      if (idx !== -1) target.parent.children.splice(idx, 1);
+    }
+  }
+  return true;
+};
+func.runtime.ui.set_display_contents = function ($element) {
+  return func.runtime.ui.set_style($element, 'display', 'contents');
+};
+func.runtime.ui.create_xurender = function (xu_ui_id, $target, hidden) {
+  const el = create_virtual_element('xurender', { 'xu-ui-id': xu_ui_id });
+  if (hidden) el.hidden = true;
+  return func.runtime.ui.append_to(el, $target);
+};
+func.runtime.ui.replace_with = function ($source, $target) {
+  if ($source?._v_id && $source.parent?._v_id) {
+    const idx = $source.parent.children.indexOf($source);
+    if (idx !== -1 && $target?._v_id) {
+      $source.parent.children[idx] = $target;
+      $target.parent = $source.parent;
+    }
+  }
+  return $target;
+};
+func.runtime.ui.remove_xu_ui = function (xu_ui_id) {
+  func.runtime.ui.delete_meta(xu_ui_id);
+  return true;
+};
+func.runtime.ui.build_debug_info = function (nodeP, $container, items) {
+  const container_data = func.runtime.ui.get_data($container);
+  return {
+    id: nodeP.id,
+    parent_id: container_data?.xuData?.ui_id,
+    items: items,
+  };
+};
+func.runtime.ui.get_node_snapshot = function (nodeP) {
+  if (!nodeP) return nodeP;
+  if (func.runtime.ui.node_snapshot_cache.has(nodeP)) {
+    return func.runtime.ui.node_snapshot_cache.get(nodeP);
+  }
+  const snapshot = typeof _ !== 'undefined' ? _.cloneDeep(nodeP) : JSON.parse(JSON.stringify(nodeP));
+  func.runtime.ui.node_snapshot_cache.set(nodeP, snapshot);
+  return snapshot;
+};
+func.runtime.ui.get_node_child_items = function (nodeP) {
+  if (!nodeP?.children?.length) return [];
+  if (func.runtime.ui.node_child_items_cache.has(nodeP)) {
+    return func.runtime.ui.node_child_items_cache.get(nodeP);
+  }
+  const items = nodeP.children.map(function (val) { return val.xu_tree_id || val.id; });
+  func.runtime.ui.node_child_items_cache.set(nodeP, items);
+  return items;
+};
+func.runtime.ui.get_node_children_by_id = function (nodeP) {
+  if (!nodeP?.children?.length) return {};
+  if (func.runtime.ui.node_children_by_id_cache.has(nodeP)) {
+    return func.runtime.ui.node_children_by_id_cache.get(nodeP);
+  }
+  const children_by_id = {};
+  for (let i = 0; i < nodeP.children.length; i++) {
+    const child = nodeP.children[i];
+    if (child?.id) children_by_id[child.id] = child;
+  }
+  func.runtime.ui.node_children_by_id_cache.set(nodeP, children_by_id);
+  return children_by_id;
+};
+func.runtime.ui.build_container_xu_data = function (options) {
+  const container_data = func.runtime.ui.get_data(options.$container);
+  const containerXuData = container_data?.xuData;
+  return {
+    SESSION_ID: options.SESSION_ID,
+    prog_id: options.paramsP.prog_id,
+    nodeid: options.nodeP.id,
+    ui_type: options.nodeP.tagName,
+    recordid: options.currentRecordId,
+    paramsP: options.paramsP,
+    key: options.keyP,
+    key_path: options.key_path,
+    screenId: options.paramsP.screenId,
+    parent_container: containerXuData?.ui_id,
+    elem_key: options.elem_key,
+    properties: options.prop,
+    node: options.nodeP,
+    node_org: func.runtime.ui.get_node_snapshot(options.nodeP),
+    is_panelP: options.paramsP.is_panelP,
+    ui_id: options.ui_id,
+    elem_prop: options.elem_propP,
+    debug_info: func.runtime.ui.build_debug_info(options.nodeP, options.$container, options.items),
+    parent_node: options.parent_nodeP,
+    currentRecordId: options.currentRecordId,
+    $root_container: options.$root_container,
+    parent_element_ui_id: containerXuData?.ui_id,
+    is_placeholder: !!options.is_placeholder,
+  };
+};
+func.runtime.ui.apply_container_meta = function ($div, options) {
+  if ($div?._v_id) $div.attrs['xu-ui-id'] = options.ui_id;
+  const xuData = func.runtime.ui.build_container_xu_data(options);
+  if (options.parent_infoP?.iterate_info) {
+    xuData.iterate_info = options.parent_infoP.iterate_info;
+  }
+  if ($div?._v_id) {
+    $div._data.xuData = xuData;
+    $div._data.xuAttributes = {};
+  }
+  func.runtime.ui.set_meta(options.ui_id, 'xuData', xuData);
+  func.runtime.ui.set_meta(options.ui_id, 'xuAttributes', {});
+  if (options.is_placeholder && $div?._v_id) $div.classList.push('display_none');
+  if (options.classP && $div?._v_id) $div.classList.push(options.classP);
+  return $div;
+};
+func.runtime.ui.get_append_target = function ($container, $appendToP) {
+  return $appendToP || $container || null;
+};
+func.runtime.ui.create_element = function (tag_name) {
+  return create_virtual_element(tag_name);
+};
+func.runtime.ui.create_svg_element = function () {
+  return create_virtual_element('svg');
+};
+func.runtime.ui.create_container_element = function (div_typeP) {
+  return create_virtual_element(div_typeP || 'div');
+};
+func.runtime.ui.build_xu_ui_id_seed = function (nodeP, dsSessionP, key_path, currentRecordId) {
+  const nodeId = nodeP.xu_tree_id || nodeP.id;
+  const elem_key = `${nodeId}-${key_path}-${currentRecordId}`;
+  return `${nodeP.id}-${elem_key}-${dsSessionP?.toString() || ''}`;
+};
+func.runtime.ui.generate_xu_ui_id = async function (SESSION_ID, nodeP, $container, paramsP, keyP, precomputed) {
+  precomputed = precomputed || {};
+  const dsSessionP = paramsP.dsSessionP;
+  const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  const containerXuData = precomputed.container_xu_data || func.runtime.ui.get_data($container)?.xuData;
+  const currentRecordId = typeof precomputed.currentRecordId !== 'undefined' ? precomputed.currentRecordId : containerXuData?.recordid || _ds?.currentRecordId || '';
+  const key_path = precomputed.key_path || `${containerXuData?.key_path || '0'}-${keyP || '0'}`;
+  const ui_id = func.runtime.ui.build_xu_ui_id_seed(nodeP, dsSessionP, key_path, currentRecordId);
+
+  if (func.runtime.ui.ui_id_hash_cache.has(ui_id)) {
+    return func.runtime.ui.ui_id_hash_cache.get(ui_id);
+  }
+
+  const hashed_ui_id = await func.common.fastHash(ui_id);
+  func.runtime.ui.ui_id_hash_cache.set(ui_id, hashed_ui_id);
+  return hashed_ui_id;
+};
+func.runtime.ui.create_container = async function (options) {
+  const _paramsP = typeof klona !== 'undefined' ? klona.klona(options.paramsP) : JSON.parse(JSON.stringify(options.paramsP));
+  const _ds = SESSION_OBJ[options.SESSION_ID].DS_GLB[_paramsP.dsSessionP];
+  const $appendTo = func.runtime.ui.get_append_target(options.$container, options.$appendToP);
+  if (!$appendTo) return null;
+  const container_data = func.runtime.ui.get_data(options.$container);
+  const container_xu_data = container_data?.xuData;
+  const items = func.runtime.ui.get_node_child_items(options.nodeP);
+  const currentRecordId = container_xu_data?.recordid || (_ds ? _ds.currentRecordId : '');
+
+  try {
+    const key_path = `${container_xu_data?.key_path || '0'}-${options.keyP || '0'}`;
+    const elem_key = `${options.nodeP.xu_tree_id || options.nodeP.id}-${key_path}-${currentRecordId}`;
+    const $div = func.runtime.ui.create_container_element(options.div_typeP);
+    const new_ui_id = await func.runtime.ui.generate_xu_ui_id(options.SESSION_ID, options.nodeP, options.$container, options.paramsP, options.keyP, {
+      container_xu_data,
+      currentRecordId,
+      key_path,
+    });
+
+    func.runtime.ui.apply_container_meta($div, {
+      ui_id: new_ui_id,
+      paramsP: _paramsP,
+      nodeP: options.nodeP,
+      currentRecordId,
+      keyP: options.keyP,
+      key_path,
+      $container: options.$container,
+      prop: options.prop,
+      elem_key,
+      elem_propP: options.elem_propP,
+      items,
+      parent_nodeP: options.parent_nodeP,
+      $root_container: options.$root_container,
+      parent_infoP: options.parent_infoP,
+      is_placeholder: options.is_placeholder,
+      classP: options.classP,
+      SESSION_ID: options.SESSION_ID,
+    });
+
+    func.runtime.ui.append_to($div, $appendTo);
+    return $div;
+  } catch (e) {
+    console.error(e);
+  }
+
+  return null;
+};
  func.datasource = {};
 func.datasource.create = async function (
   SESSION_ID,
@@ -7576,7 +7965,7 @@ func.events.execute = async function (
   var field_elm = elementP;
 
   var calling_field_id = field_elm;
-  if (field_elm && typeof field_elm === 'object') calling_field_id = field_elm.attr('xu-ui-id');
+  if (field_elm && typeof field_elm === 'object') calling_field_id = func.runtime.ui.get_attr(field_elm, 'xu-ui-id');
 
   var log_nodeId;
   var log_prog_id;

package/package.json

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