@xuda.io/runtime-bundle 1.0.1246 → 1.0.1248

package/js/xuda-runtime-bundle.js

@@ -24677,11 +24677,6 @@ func.common.get_data_from_websocket = async function (SESSION_ID, serviceP, data
 };
 
 func.common.sha256 = async function (inputString) {
-  // const enc = new TextEncoder();
-  // const buf = await crypto.subtle.digest('SHA-256', enc.encode(str));
-  // const bytes = new Uint8Array(buf);
-  // return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
-
   // 1. Create a hash buffer from the input string using SHA-256.
   // This part remains the same as it provides a strong, unique cryptographic starting point.
   const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(inputString));
@@ -28583,7 +28578,7 @@ func.datasource.prepare = async function (SESSION_ID, prog_id, dataSourceNoP, pa
         _ds.data_feed = {};
 
         // _ds.v.old_dataSource = _.cloneDeep(_ds);
-        _ds.v.old_dataSource = klona(_ds);
+        _ds.v.old_dataSource = klona.klona(_ds);
       } catch (err) {
         console.error('function: init_existing_dataSource - error');
         return;
@@ -30214,11 +30209,11 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
         }
 
         // 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(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(fields_changed), // _.cloneDeep(fields_changed),
+          klona.klona(fields_changed), // _.cloneDeep(fields_changed),
           null,
           datasource_changed[0], // refresh the current datasource only
         );
@@ -30870,7 +30865,7 @@ func.datasource.set_VIEW_data = async function (SESSION_ID, args, _ds) {
   _ds.viewEventExec_arr = {};
 
   // var view = _.cloneDeep(await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id));
-  var view = klona(await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id));
+  var view = klona.klona(await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id));
 
   _ds.v.dataSourceSrcType = view.dataSourceSrcType;
 
@@ -31040,7 +31035,7 @@ func.UI.screen.init = async function (SESSION_ID, prog_id, sourceScreenP, callin
   let _session = SESSION_OBJ[SESSION_ID];
 
   // const screenInfo = _.cloneDeep(screen_ret);
-  const screenInfo = klona(screen_ret);
+  const screenInfo = klona.klona(screen_ret);
 
   var screen_type = source_functionP?.split('_')?.[1]; //|| (is_panelP && "panel");
 
@@ -31185,7 +31180,7 @@ func.UI.screen.init = async function (SESSION_ID, prog_id, sourceScreenP, callin
     }
     var node;
     // node = _.cloneDeep(viewDoc.progUi);
-    node = klona(viewDoc.progUi);
+    node = klona.klona(viewDoc.progUi);
     if (!node.length) return console.warn('ui node empty');
     const ret_render_$container = await func.UI.screen.render_ui_tree(SESSION_ID, $rootFrame, node[0], null, params, jobNoP, null, null, null, null, null, $rootFrame);
 
@@ -31752,7 +31747,7 @@ func.UI.screen.refresh_screen = async function (SESSION_ID, fields_changed_arr,
             const new_$div = await func.UI.screen.render_ui_tree(
               SESSION_ID,
               $elm, // the wrapper
-              klona($elm.data().xuData.node), //_.cloneDeep($elm.data().xuData.node), // the xu-panel node
+              klona.klona($elm.data().xuData.node), //_.cloneDeep($elm.data().xuData.node), // the xu-panel node
               {},
               elm_data.xuData.paramsP, // the wrapper params
               null,
@@ -32716,7 +32711,7 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
             reference_source_obj,
           };
           // let _parent_info = _.cloneDeep(parent_infoP) || {};
-          let _parent_info = klona(parent_infoP) || {};
+          let _parent_info = klona.klona(parent_infoP) || {};
           _parent_info.iterate_info = iterate_info;
 
           const $divP = await func.UI.screen.render_ui_tree(
@@ -33044,62 +33039,408 @@ func.UI.screen.fix_val_defaults = function (key, val) {
   return ret;
 };
 
+// func.UI.screen.set_attributes_new = async function (SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, $elm, is_init, execute_attributes = [], refreshed_ds) {
+//   var done_exp = [];
+
+//   const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
+//   if (!_ds) return { abort: true };
+
+//   const get_attr_value = async function (key) {
+//     let ret = func.UI.screen.fix_val_defaults(key, nodeP.attributes[key]);
+//     if (nodeP?.attributes?.hasOwnProperty(`xu-exp:${key}`)) {
+//       ret = await get_xuExp(key);
+//     }
+//     return ret;
+//   };
+
+//   const get_xuExp = async function (attrib) {
+//     if (is_skeleton) return;
+//     if (glb.new_xu_render) {
+//       let _xuData = $elm.data().xuData;
+//       if (!_xuData.attr_exp_info) {
+//         _xuData.attr_exp_info = {};
+//       }
+//     }
+//     const attr = `xu-exp:${attrib}`;
+
+//     if (!nodeP?.attributes?.hasOwnProperty(attr)) return;
+//     // const attr = `xu-exp-${attrib}`;
+//     var exp = nodeP.attributes[attr];
+//     // if (!value) return func.UI.screen.fix_val_defaults(attrib, exp || nodeP.attributes[attrib]);
+
+//     var res = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', _ds.currentRecordId);
+//     if (glb.new_xu_render) {
+//       _xuData.attr_exp_info[attrib] = res;
+//     }
+//     // nodeP.attributes[attr] = value; //{ value: value, res: res };
+//     done_exp.push(attr);
+//     return res.result; //func.UI.screen.fix_val_defaults(attrib, res.result);
+//   };
+
+//   var _ret = {};
+//   if (nodeP.type !== 'element' || !nodeP.attributes) return _ret;
+
+//   for (let [key, val] of Object.entries(nodeP.attributes)) {
+//     // REMOVE STATIC ATTRIBUTES IF EXP EXISTS to avoid dup
+//     if (key.substring(0, 6) === 'xu-exp') {
+//       if (_.isEmpty(val)) {
+//         delete nodeP.attributes[key];
+//         continue;
+//       }
+//       const clean_key = key.split(':')[1];
+//       if (typeof nodeP.attributes[clean_key] !== 'undefined') {
+//         delete nodeP.attributes[clean_key];
+//       }
+//     }
+//     // FIX abbreviations
+//     if (glb.attr_abbreviations_arr.includes(key)) {
+//       nodeP.attributes[`xu-on:${key.substring(3)}`] = [
+//         {
+//           handler: 'custom',
+//           props: {},
+//           event: [
+//             {
+//               id: Date.now(),
+//               data: {
+//                 action: 'update',
+//                 name: { value: val },
+//                 enabled: true,
+//               },
+//               props: {},
+//             },
+//           ],
+//         },
+//       ];
+//       delete nodeP.attributes[key];
+//     }
+//   }
+
+//   for (let [key, val] of Object.entries(nodeP.attributes)) {
+//     // FIX STATIC DEFAULTS
+//     val = func.UI.screen.fix_val_defaults(key, val);
+
+//     // REMOVE UNDEFINED or NULL ATTRIBUTES
+//     if (typeof val === 'undefined' || val === null) {
+//       delete nodeP.attributes[key];
+//     }
+
+//     // REMOVE ATTRIBUTES WITH EMPTY VALUES
+//     if (glb.solid_attributes.includes(key) && !val) {
+//       delete nodeP.attributes[key];
+//     }
+//   }
+
+//   // XU-ATTRS
+//   if (nodeP?.attributes?.['xu-attrs'] || nodeP?.attributes?.['xu-exp:xu-attrs']) {
+//     const attr = 'xu-attrs';
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       attr,
+//       $elm,
+//       {
+//         key: attr,
+//         value: await get_attr_value(attr),
+//       },
+//       is_init,
+//     );
+//   }
+
+//   // BEFORE
+//   if (!_.isEmpty(nodeP.attributes)) {
+//     for await (const [key, attr] of Object.entries(glb.run_xu_before)) {
+//       if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
+//       if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) {
+//         continue;
+//       }
+
+//       if (!nodeP?.attributes?.hasOwnProperty(attr) && !nodeP?.attributes?.hasOwnProperty(`xu-exp:${attr}`)) {
+//         continue;
+//       }
+
+//       if (!nodeP.attributes[`xu-exp:${attr}`] && nodeP?.attributes?.hasOwnProperty(attr) && typeof func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]) === 'undefined') {
+//         continue;
+//       }
+
+//       let ret = await func.UI.screen.execute_xu_functions(
+//         SESSION_ID,
+//         is_skeleton,
+//         $root_container,
+//         nodeP,
+//         $container,
+//         paramsP,
+//         parent_infoP,
+//         jobNoP,
+//         keyP,
+//         parent_nodeP,
+//         attr,
+//         $elm,
+//         {
+//           key: attr,
+
+//           value: await get_attr_value(attr),
+//         },
+//         is_init,
+//       );
+//       _ret = _.assignIn(_ret, ret);
+//     }
+//   }
+
+//   // ALL
+
+//   for await (const [key, val] of Object.entries(nodeP.attributes)) {
+//     if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
+//     if (glb.html5_events_handler.includes(key) || execute_attributes.includes(key)) {
+//       continue;
+//     }
+
+//     const new_key = key.split(':')[0]; // break expression
+//     if (
+//       nodeP.tagName !== 'xu-panel' &&
+//       nodeP.tagName !== 'xu-teleport' && //  nodeP.tagName.substr(0, 3) !== "xu-" &&
+//       (new_key.substr(0, 2) !== 'xu' || new_key.substr(2, 1) !== '-')
+//     ) {
+//       // handle common html attributes
+//       try {
+//         $elm.get(0).setAttribute(key, val);
+//       } catch (err) {
+//         console.error(err.message);
+//       }
+
+//       continue;
+//     }
+//     // handle xu attributes
+//     try {
+//       if ($elm?.data()?.xuAttributes) {
+//         // in some cases xu data delete in purpose when refreshing the screen
+//         $elm.data().xuAttributes[key] = val;
+//       }
+//     } catch (error) {
+//       debugger;
+//       console.error(error);
+//     }
+
+//     if (new_key === 'xu-exp' || nodeP.attributes['xu-exp:' + new_key] || glb.run_xu_before.includes(new_key) || glb.run_xu_after.includes(new_key)) {
+//       continue;
+//     }
+
+//     if (new_key === 'xu-on') {
+//       let ret = await func.UI.screen.execute_xu_functions(
+//         SESSION_ID,
+//         is_skeleton,
+//         $root_container,
+//         nodeP,
+//         $container,
+//         paramsP,
+//         parent_infoP,
+//         jobNoP,
+//         keyP,
+//         parent_nodeP,
+//         'xu-on',
+//         $elm,
+//         {
+//           key: key,
+//           // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
+//           value: await get_attr_value(key),
+//         },
+//         is_init,
+//         refreshed_ds,
+//       );
+//       _ret = _.assignIn(_ret, ret);
+//       continue;
+//     }
+
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       new_key,
+//       $elm,
+//       {
+//         key: key,
+//         // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
+//         value: await get_attr_value(key),
+//       },
+//       is_init,
+//       refreshed_ds,
+//     );
+
+//     _ret = _.assignIn(_ret, ret);
+//   }
+
+//   // EXP for
+
+//   for await (const [key, val] of Object.entries(nodeP.attributes)) {
+//     if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
+
+//     const attr = key.split('xu-exp:')[1];
+
+//     if (!attr) {
+//       continue;
+//     }
+
+//     if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
+
+//     if (done_exp.includes(key)) {
+//       continue;
+//     }
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       'xu-exp',
+//       $elm,
+//       {
+//         key: attr,
+//         value: val,
+//       },
+//       true,
+//       refreshed_ds,
+//     );
+//     _ret = _.assignIn(_ret, ret);
+//   }
+
+//   // AFTER
+
+//   for await (const [key, attr] of Object.entries(glb.run_xu_after)) {
+//     if ($container?.data()?.xuData?.pending_to_delete) break;
+
+//     if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
+
+//     if (!nodeP.attributes || !nodeP.attributes[attr] & !nodeP.attributes[`xu-exp:${attr}`]) continue;
+
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       attr,
+//       $elm,
+//       {
+//         key: attr,
+//         // value: (await get_xuExp(attr)) || func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]),
+//         value: await get_attr_value(attr),
+//       },
+//       is_init,
+//       refreshed_ds,
+//     );
+//     _ret = _.assignIn(_ret, ret);
+//   }
+
+//   // REGISTER EVENTS ATTRIBUTES
+
+//   for await (const [key, val] of Object.entries(nodeP.attributes)) {
+//     if ($container?.data()?.xuData?.pending_to_delete) break;
+//     if (!glb.html5_events_handler.includes(key)) break;
+//     // $elm.attr(key, await get_xuExp(key)) || val;
+//     $elm.attr(key, await get_xuExp(key)) || val;
+//   }
+
+//   return _ret;
+// };
+
 func.UI.screen.set_attributes_new = async function (SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, $elm, is_init, execute_attributes = [], refreshed_ds) {
-  var done_exp = [];
+  const done_exp = new Set(); // Use Set for O(1) lookups instead of array
 
   const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
   if (!_ds) return { abort: true };
 
+  // Early return if not an element or no attributes
+  if (nodeP.type !== 'element' || !nodeP.attributes) return {};
+
+  // Cache frequently accessed values
+  const nodeAttrs = nodeP.attributes;
+  const elmData = $elm.data();
+  const xuData = elmData.xuData;
+  const containerData = $container?.data();
+  const containerXuData = containerData?.xuData;
+
   const get_attr_value = async function (key) {
-    let ret = func.UI.screen.fix_val_defaults(key, nodeP.attributes[key]);
-    if (nodeP?.attributes?.hasOwnProperty(`xu-exp:${key}`)) {
-      ret = await get_xuExp(key);
+    const expKey = `xu-exp:${key}`;
+    if (nodeAttrs.hasOwnProperty(expKey)) {
+      return await get_xuExp(key);
     }
-    return ret;
+    return func.UI.screen.fix_val_defaults(key, nodeAttrs[key]);
   };
 
   const get_xuExp = async function (attrib) {
     if (is_skeleton) return;
+
+    const attr = `xu-exp:${attrib}`;
+    if (!nodeAttrs.hasOwnProperty(attr)) return;
+
     if (glb.new_xu_render) {
-      let _xuData = $elm.data().xuData;
-      if (!_xuData.attr_exp_info) {
-        _xuData.attr_exp_info = {};
+      if (!xuData.attr_exp_info) {
+        xuData.attr_exp_info = {};
       }
     }
-    const attr = `xu-exp:${attrib}`;
 
-    if (!nodeP?.attributes?.hasOwnProperty(attr)) return;
-    // const attr = `xu-exp-${attrib}`;
-    var exp = nodeP.attributes[attr];
-    // if (!value) return func.UI.screen.fix_val_defaults(attrib, exp || nodeP.attributes[attrib]);
+    const exp = nodeAttrs[attr];
+    const res = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', _ds.currentRecordId);
 
-    var res = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', _ds.currentRecordId);
     if (glb.new_xu_render) {
-      _xuData.attr_exp_info[attrib] = res;
+      xuData.attr_exp_info[attrib] = res;
     }
-    // nodeP.attributes[attr] = value; //{ value: value, res: res };
-    done_exp.push(attr);
-    return res.result; //func.UI.screen.fix_val_defaults(attrib, res.result);
-  };
 
-  var _ret = {};
-  if (nodeP.type !== 'element' || !nodeP.attributes) return _ret;
+    done_exp.add(attr);
+    return res.result;
+  };
 
-  for (let [key, val] of Object.entries(nodeP.attributes)) {
-    // REMOVE STATIC ATTRIBUTES IF EXP EXISTS to avoid dup
-    if (key.substring(0, 6) === 'xu-exp') {
+  // Create Sets for O(1) lookups
+  const html5EventsSet = new Set(glb.html5_events_handler);
+  const executeAttrsSet = new Set(execute_attributes);
+  const solidAttrsSet = new Set(glb.solid_attributes);
+  const abbreviationsSet = new Set(glb.attr_abbreviations_arr);
+  const runXuBeforeSet = new Set(Object.values(glb.run_xu_before));
+  const runXuAfterSet = new Set(Object.values(glb.run_xu_after));
+
+  // Process attributes in a single pass where possible
+  const attrsToDelete = [];
+  const xuOnAttrs = {};
+
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    // Handle xu-exp attributes
+    if (key.startsWith('xu-exp:')) {
       if (_.isEmpty(val)) {
-        delete nodeP.attributes[key];
+        attrsToDelete.push(key);
         continue;
       }
-      const clean_key = key.split(':')[1];
-      if (typeof nodeP.attributes[clean_key] !== 'undefined') {
-        delete nodeP.attributes[clean_key];
+      const clean_key = key.slice(7); // 'xu-exp:'.length = 7
+      if (nodeAttrs[clean_key] !== undefined) {
+        attrsToDelete.push(clean_key);
       }
     }
-    // FIX abbreviations
-    if (glb.attr_abbreviations_arr.includes(key)) {
-      nodeP.attributes[`xu-on:${key.substring(3)}`] = [
+    // Handle abbreviations
+    else if (abbreviationsSet.has(key)) {
+      xuOnAttrs[`xu-on:${key.slice(3)}`] = [
         {
           handler: 'custom',
           props: {},
@@ -33116,257 +33457,131 @@ func.UI.screen.set_attributes_new = async function (SESSION_ID, is_skeleton, $ro
           ],
         },
       ];
-      delete nodeP.attributes[key];
+      attrsToDelete.push(key);
     }
   }
 
-  for (let [key, val] of Object.entries(nodeP.attributes)) {
-    // FIX STATIC DEFAULTS
-    val = func.UI.screen.fix_val_defaults(key, val);
+  // Delete marked attributes
+  for (const key of attrsToDelete) {
+    delete nodeAttrs[key];
+  }
 
-    // REMOVE UNDEFINED or NULL ATTRIBUTES
-    if (typeof val === 'undefined' || val === null) {
-      delete nodeP.attributes[key];
-    }
+  // Add xu-on attributes
+  Object.assign(nodeAttrs, xuOnAttrs);
+
+  // Clean up attributes
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    const fixedVal = func.UI.screen.fix_val_defaults(key, val);
 
-    // REMOVE ATTRIBUTES WITH EMPTY VALUES
-    if (glb.solid_attributes.includes(key) && !val) {
-      delete nodeP.attributes[key];
+    if (fixedVal === undefined || fixedVal === null) {
+      delete nodeAttrs[key];
+    } else if (solidAttrsSet.has(key) && !fixedVal) {
+      delete nodeAttrs[key];
+    } else {
+      nodeAttrs[key] = fixedVal;
     }
   }
 
+  const _ret = {};
+
+  // Helper to check abort condition
+  const shouldAbort = () => _ret.abort || containerXuData?.pending_to_delete;
+
   // XU-ATTRS
-  if (nodeP?.attributes?.['xu-attrs'] || nodeP?.attributes?.['xu-exp:xu-attrs']) {
+  if (nodeAttrs['xu-attrs'] || nodeAttrs['xu-exp:xu-attrs']) {
     const attr = 'xu-attrs';
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      attr,
-      $elm,
-      {
-        key: attr,
-        value: await get_attr_value(attr),
-      },
-      is_init,
-    );
+    await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, attr, $elm, { key: attr, value: await get_attr_value(attr) }, is_init);
   }
 
   // BEFORE
-  if (!_.isEmpty(nodeP.attributes)) {
-    for await (const [key, attr] of Object.entries(glb.run_xu_before)) {
-      if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
-      if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) {
-        continue;
-      }
-
-      if (!nodeP?.attributes?.hasOwnProperty(attr) && !nodeP?.attributes?.hasOwnProperty(`xu-exp:${attr}`)) {
-        continue;
-      }
-
-      if (!nodeP.attributes[`xu-exp:${attr}`] && nodeP?.attributes?.hasOwnProperty(attr) && typeof func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]) === 'undefined') {
-        continue;
-      }
+  if (!_.isEmpty(nodeAttrs)) {
+    for (const [key, attr] of Object.entries(glb.run_xu_before)) {
+      if (shouldAbort()) break;
+      if (html5EventsSet.has(attr) || executeAttrsSet.has(attr)) continue;
 
-      let ret = await func.UI.screen.execute_xu_functions(
-        SESSION_ID,
-        is_skeleton,
-        $root_container,
-        nodeP,
-        $container,
-        paramsP,
-        parent_infoP,
-        jobNoP,
-        keyP,
-        parent_nodeP,
-        attr,
-        $elm,
-        {
-          key: attr,
+      const expKey = `xu-exp:${attr}`;
+      if (!nodeAttrs.hasOwnProperty(attr) && !nodeAttrs.hasOwnProperty(expKey)) continue;
+      if (!nodeAttrs[expKey] && nodeAttrs.hasOwnProperty(attr) && func.UI.screen.fix_val_defaults(attr, nodeAttrs[attr]) === undefined) continue;
 
-          value: await get_attr_value(attr),
-        },
-        is_init,
-      );
-      _ret = _.assignIn(_ret, ret);
+      const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, attr, $elm, { key: attr, value: await get_attr_value(attr) }, is_init);
+      Object.assign(_ret, ret);
     }
   }
 
-  // ALL
+  // ALL - Process attributes
+  const isXuPanel = nodeP.tagName === 'xu-panel';
+  const isXuTeleport = nodeP.tagName === 'xu-teleport';
+  const elmElement = $elm.get(0);
 
-  for await (const [key, val] of Object.entries(nodeP.attributes)) {
-    if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
-    if (glb.html5_events_handler.includes(key) || execute_attributes.includes(key)) {
-      continue;
-    }
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    if (shouldAbort()) break;
+    if (html5EventsSet.has(key) || executeAttrsSet.has(key)) continue;
 
-    const new_key = key.split(':')[0]; // break expression
-    if (
-      nodeP.tagName !== 'xu-panel' &&
-      nodeP.tagName !== 'xu-teleport' && //  nodeP.tagName.substr(0, 3) !== "xu-" &&
-      (new_key.substr(0, 2) !== 'xu' || new_key.substr(2, 1) !== '-')
-    ) {
-      // handle common html attributes
+    const colonIndex = key.indexOf(':');
+    const new_key = colonIndex > -1 ? key.slice(0, colonIndex) : key;
+
+    if (!isXuPanel && !isXuTeleport && (!new_key.startsWith('xu-') || new_key.length < 3 || new_key[2] !== '-')) {
       try {
-        $elm.get(0).setAttribute(key, val);
+        elmElement.setAttribute(key, val);
       } catch (err) {
         console.error(err.message);
       }
-
       continue;
     }
-    // handle xu attributes
-    try {
-      if ($elm?.data()?.xuAttributes) {
-        // in some cases xu data delete in purpose when refreshing the screen
-        $elm.data().xuAttributes[key] = val;
-      }
-    } catch (error) {
-      debugger;
-      console.error(error);
+
+    // Store xu attributes
+    if (elmData.xuAttributes) {
+      elmData.xuAttributes[key] = val;
     }
 
-    if (new_key === 'xu-exp' || nodeP.attributes['xu-exp:' + new_key] || glb.run_xu_before.includes(new_key) || glb.run_xu_after.includes(new_key)) {
+    const expKey = `xu-exp:${new_key}`;
+    if (new_key === 'xu-exp' || nodeAttrs[expKey] || runXuBeforeSet.has(new_key) || runXuAfterSet.has(new_key)) {
       continue;
     }
 
     if (new_key === 'xu-on') {
-      let ret = await func.UI.screen.execute_xu_functions(
-        SESSION_ID,
-        is_skeleton,
-        $root_container,
-        nodeP,
-        $container,
-        paramsP,
-        parent_infoP,
-        jobNoP,
-        keyP,
-        parent_nodeP,
-        'xu-on',
-        $elm,
-        {
-          key: key,
-          // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
-          value: await get_attr_value(key),
-        },
-        is_init,
-        refreshed_ds,
-      );
-      _ret = _.assignIn(_ret, ret);
+      const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, 'xu-on', $elm, { key: key, value: await get_attr_value(key) }, is_init, refreshed_ds);
+      Object.assign(_ret, ret);
       continue;
     }
 
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      new_key,
-      $elm,
-      {
-        key: key,
-        // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
-        value: await get_attr_value(key),
-      },
-      is_init,
-      refreshed_ds,
-    );
-
-    _ret = _.assignIn(_ret, ret);
+    const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, new_key, $elm, { key: key, value: await get_attr_value(key) }, is_init, refreshed_ds);
+    Object.assign(_ret, ret);
   }
 
-  // EXP for
+  // EXP - Process expressions
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    if (shouldAbort()) break;
 
-  for await (const [key, val] of Object.entries(nodeP.attributes)) {
-    if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
+    if (!key.startsWith('xu-exp:')) continue;
+    const attr = key.slice(7);
 
-    const attr = key.split('xu-exp:')[1];
+    if (html5EventsSet.has(attr) || executeAttrsSet.has(attr)) continue;
+    if (done_exp.has(key)) continue;
 
-    if (!attr) {
-      continue;
-    }
-
-    if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
-
-    if (done_exp.includes(key)) {
-      continue;
-    }
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      'xu-exp',
-      $elm,
-      {
-        key: attr,
-        value: val,
-      },
-      true,
-      refreshed_ds,
-    );
-    _ret = _.assignIn(_ret, ret);
+    const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, 'xu-exp', $elm, { key: attr, value: val }, true, refreshed_ds);
+    Object.assign(_ret, ret);
   }
 
   // AFTER
+  for (const [key, attr] of Object.entries(glb.run_xu_after)) {
+    if (containerXuData?.pending_to_delete) break;
+    if (html5EventsSet.has(attr) || executeAttrsSet.has(attr)) continue;
 
-  for await (const [key, attr] of Object.entries(glb.run_xu_after)) {
-    if ($container?.data()?.xuData?.pending_to_delete) break;
-
-    if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
-
-    if (!nodeP.attributes || !nodeP.attributes[attr] & !nodeP.attributes[`xu-exp:${attr}`]) continue;
+    const expKey = `xu-exp:${attr}`;
+    if (!nodeAttrs || (!nodeAttrs[attr] && !nodeAttrs[expKey])) continue;
 
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      attr,
-      $elm,
-      {
-        key: attr,
-        // value: (await get_xuExp(attr)) || func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]),
-        value: await get_attr_value(attr),
-      },
-      is_init,
-      refreshed_ds,
-    );
-    _ret = _.assignIn(_ret, ret);
+    const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, attr, $elm, { key: attr, value: await get_attr_value(attr) }, is_init, refreshed_ds);
+    Object.assign(_ret, ret);
   }
 
   // REGISTER EVENTS ATTRIBUTES
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    if (containerXuData?.pending_to_delete) break;
+    if (!html5EventsSet.has(key)) break;
 
-  for await (const [key, val] of Object.entries(nodeP.attributes)) {
-    if ($container?.data()?.xuData?.pending_to_delete) break;
-    if (!glb.html5_events_handler.includes(key)) break;
-    // $elm.attr(key, await get_xuExp(key)) || val;
-    $elm.attr(key, await get_xuExp(key)) || val;
+    const expVal = await get_xuExp(key);
+    $elm.attr(key, expVal || val);
   }
 
   return _ret;
@@ -33431,7 +33646,7 @@ func.UI.screen.panel_post_render_handler = async function (
 
 const generate_xu_ui_id = async function (SESSION_ID, nodeP, $container, paramsP, keyP) {
   // const _paramsP = _.cloneDeep(paramsP);
-  const _paramsP = klona(paramsP);
+  const _paramsP = klona.klona(paramsP);
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[_paramsP.dsSessionP];
 
   const currentRecordId = $container?.data?.()?.xuData?.recordid || (_ds ? _ds.currentRecordId : '');
@@ -33445,7 +33660,7 @@ const generate_xu_ui_id = async function (SESSION_ID, nodeP, $container, paramsP
 
 func.UI.screen.create_container = async function (SESSION_ID, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, prop, classP, elem_propP, div_typeP, $appendToP, attr_str, is_placeholder) {
   // const _paramsP = _.cloneDeep(paramsP);
-  const _paramsP = klona(paramsP);
+  const _paramsP = klona.klona(paramsP);
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[_paramsP.dsSessionP];
   var $appendTo = $container;
   if ($appendToP) $appendTo = $appendToP;
@@ -34463,7 +34678,7 @@ func.UI.screen.render_ui_tree = async function (SESSION_ID, $container, nodeP, p
       });
       $.each($div.data().xuAttributes, function (key, val) {
         // $container.data().xuAttributes[key] = _.cloneDeep(val);
-        $container.data().xuAttributes[key] = klona(val);
+        $container.data().xuAttributes[key] = klona.klona(val);
       });
 
       return await render_screen_type($div);