@xuda.io/xuda-worker-bundle 1.3.2694 → 1.3.2696

package/index.js

@@ -291,7 +291,30 @@ func.runtime.platform.emit = function (name, data) {
 };
 
 // ── Platform helpers for DOM-independent resource loading ──
-func.runtime.platform.load_script = function (url, type, callback) {
+func.runtime.platform.apply_element_attributes = function (node, attributes, excluded_keys = []) {
+  if (!node?.setAttribute || !attributes) {
+    return node;
+  }
+
+  const excluded = new Set(excluded_keys || []);
+  const attr_keys = Object.keys(attributes);
+  for (let index = 0; index < attr_keys.length; index++) {
+    const key = attr_keys[index];
+    if (!key || excluded.has(key)) {
+      continue;
+    }
+
+    const value = attributes[key];
+    if (value === false || typeof value === 'undefined') {
+      continue;
+    }
+
+    node.setAttribute(key, value === null ? '' : `${value}`);
+  }
+
+  return node;
+};
+func.runtime.platform.load_script = function (url, type, callback, attributes) {
   const doc = func.runtime.platform.get_document();
   if (!doc?.createElement || !doc?.head?.appendChild) {
     if (callback) {
@@ -299,19 +322,63 @@ func.runtime.platform.load_script = function (url, type, callback) {
     }
     return;
   }
+  const find_existing_script = function () {
+    const asset_key = attributes?.['data-xuda-asset-key'];
+    const scripts = doc.querySelectorAll ? Array.from(doc.querySelectorAll('script')) : [];
+    return scripts.find(function (script) {
+      if (asset_key && script.getAttribute('data-xuda-asset-key') === asset_key) {
+        return true;
+      }
+      return !!(url && script.getAttribute('src') === url);
+    }) || null;
+  };
+
+  const existing_script = find_existing_script();
+  if (existing_script) {
+    if (callback) {
+      if (existing_script.getAttribute('data-xuda-loaded') === 'true' || !url) {
+        callback();
+      } else {
+        existing_script.addEventListener('load', callback, { once: true });
+        existing_script.addEventListener('error', callback, { once: true });
+      }
+    }
+    return existing_script;
+  }
+
   const script = doc.createElement('script');
   script.src = url;
   if (type) script.type = type;
-  script.onload = callback;
+  func.runtime.platform.apply_element_attributes(script, attributes, ['src', 'type']);
+  script.onload = function () {
+    script.setAttribute('data-xuda-loaded', 'true');
+    if (callback) {
+      callback();
+    }
+  };
+  script.onerror = function () {
+    if (callback) {
+      callback();
+    }
+  };
   doc.head.appendChild(script);
+  return script;
 };
-func.runtime.platform.load_css = function (href) {
+func.runtime.platform.load_css = function (href, attributes) {
   const doc = func.runtime.platform.get_document();
   if (!doc?.createElement || !doc?.head) {
     return;
   }
   try {
-    if (doc.querySelector('link[href="' + href + '"]')) return;
+    const asset_key = attributes?.['data-xuda-asset-key'];
+    const existing_links = doc.querySelectorAll ? Array.from(doc.querySelectorAll('link')) : [];
+    const existing = existing_links.find(function (link) {
+      if (asset_key && link.getAttribute('data-xuda-asset-key') === asset_key) {
+        return true;
+      }
+      return !!(href && link.getAttribute('href') === href);
+    });
+    if (existing) return existing;
   } catch (err) {
     return;
   }
@@ -319,7 +386,9 @@ func.runtime.platform.load_css = function (href) {
   link.rel = 'stylesheet';
   link.type = 'text/css';
   link.href = href;
+  func.runtime.platform.apply_element_attributes(link, attributes, ['href']);
   doc.head.insertBefore(link, doc.head.firstChild);
+  return link;
 };
 func.runtime.platform.remove_js_css = function (filename, filetype) {
   const doc = func.runtime.platform.get_document();
@@ -353,6 +422,128 @@ func.runtime.platform.set_cursor = function (element, cursor) {
     node.style.cursor = cursor;
   }
 };
+func.runtime.program.normalize_doc_for_runtime = function (doc) {
+  if (!doc || doc.__xudaRuntimeNormalized || !Array.isArray(doc.progUi) || !doc.progUi.length) {
+    return doc;
+  }
+
+  const normalize_tag_name = function (tag_name) {
+    return `${tag_name || ''}`.trim().toLowerCase();
+  };
+  const merge_attributes = function (target, source) {
+    const merged = { ...(target || {}) };
+    const source_attributes = source || {};
+    const keys = Object.keys(source_attributes);
+
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      const value = source_attributes[key];
+      if (typeof value === 'undefined') {
+        continue;
+      }
+
+      if (key === 'class' && merged.class && value) {
+        const next_value = `${merged.class} ${value}`.trim();
+        merged.class = Array.from(new Set(next_value.split(/\s+/).filter(Boolean))).join(' ');
+        continue;
+      }
+
+      if (key === 'style' && merged.style && value) {
+        merged.style = `${merged.style}; ${value}`.trim();
+        continue;
+      }
+
+      if (typeof merged[key] === 'undefined') {
+        merged[key] = value;
+      }
+    }
+
+    return merged;
+  };
+  const normalize_nodes = function (nodes, state) {
+    const normalized_nodes = [];
+
+    for (let index = 0; index < (nodes || []).length; index++) {
+      const node = nodes[index];
+      if (!node || typeof node !== 'object') {
+        continue;
+      }
+
+      const tag_name = normalize_tag_name(node.tagName);
+
+      if (tag_name === '!doctype') {
+        state.changed = true;
+        continue;
+      }
+
+      if (tag_name === 'html') {
+        state.changed = true;
+        state.root_attributes = merge_attributes(state.root_attributes, node.attributes);
+        normalized_nodes.push.apply(normalized_nodes, normalize_nodes(node.children, state));
+        continue;
+      }
+
+      if (tag_name === 'head') {
+        state.changed = true;
+        normalized_nodes.push.apply(normalized_nodes, normalize_nodes(node.children, state));
+        continue;
+      }
+
+      if (tag_name === 'body') {
+        state.changed = true;
+        state.root_attributes = merge_attributes(state.root_attributes, node.attributes);
+        normalized_nodes.push.apply(normalized_nodes, normalize_nodes(node.children, state));
+        continue;
+      }
+
+      let next_node = node;
+      if (Array.isArray(node.children) && node.children.length) {
+        const next_children = normalize_nodes(node.children, state);
+        if (next_children !== node.children) {
+          next_node = {
+            ...node,
+            children: next_children,
+          };
+          state.changed = true;
+        }
+      }
+
+      normalized_nodes.push(next_node);
+    }
+
+    return normalized_nodes;
+  };
+
+  const [root_node, ...extra_nodes] = doc.progUi;
+  if (!root_node || typeof root_node !== 'object') {
+    return doc;
+  }
+
+  const state = {
+    changed: false,
+    root_attributes: {},
+  };
+
+  const normalized_children = normalize_nodes([...(root_node.children || []), ...extra_nodes], state);
+  const merged_attributes = merge_attributes(root_node.attributes, state.root_attributes);
+
+  if (!state.changed && !Object.keys(state.root_attributes).length) {
+    doc.__xudaRuntimeNormalized = true;
+    return doc;
+  }
+
+  return {
+    ...doc,
+    __xudaRuntimeNormalized: true,
+    progUi: [
+      {
+        ...root_node,
+        attributes: merged_attributes,
+        children: normalized_children,
+      },
+    ],
+  };
+};
 
 func.runtime.env = {
   get_url_params: function () {
@@ -1154,10 +1345,10 @@ func.runtime.resources.load_cdn = async function (SESSION_ID, resource) {
           await func.utils.load_js_on_demand(normalized_resource.src);
           break;
         case 'css':
-          await func.utils.load_js_on_demand(normalized_resource.src);
+          func.runtime.platform.load_css(normalized_resource.src);
           break;
         case 'module':
-          func.utils.load_js_on_demand(normalized_resource.src, 'module');
+          await func.utils.load_js_on_demand(normalized_resource.src, 'module');
           break;
         default:
           await func.utils.load_js_on_demand(normalized_resource.src);
@@ -6886,6 +7077,13 @@ func.utils.DOCS_OBJ = {};
 func.utils.DOCS_OBJ.get = async function (SESSION_ID, idP) {
   if (!idP || idP === '0') return;
 
+  const normalize_runtime_doc = function (doc) {
+    if (!doc || !func.runtime.program?.normalize_doc_for_runtime) {
+      return doc;
+    }
+    return func.runtime.program.normalize_doc_for_runtime(doc);
+  };
+
   var _session = SESSION_OBJ[SESSION_ID];
   const _app_id = _session.app_id;
   if (!DOCS_OBJ[_app_id]) {
@@ -6907,7 +7105,8 @@ func.utils.DOCS_OBJ.get = async function (SESSION_ID, idP) {
     }
     let val = _session.project_data?.programs?.[idP];
     if (val) {
-      return (DOCS_OBJ[_app_id][idP] = val);
+      DOCS_OBJ[_app_id][idP] = normalize_runtime_doc(val);
+      return DOCS_OBJ[_app_id][idP];
     }
   }
 
@@ -6915,7 +7114,7 @@ func.utils.DOCS_OBJ.get = async function (SESSION_ID, idP) {
     const module = await func.common.get_module(SESSION_ID, `xuda-progs-loader-module.mjs`);
 
     if (idP !== 'system') {
-      DOCS_OBJ[_app_id][idP] = await module.DOCS_OBJ_get(SESSION_ID, idP);
+      DOCS_OBJ[_app_id][idP] = normalize_runtime_doc(await module.DOCS_OBJ_get(SESSION_ID, idP));
       if (DOCS_OBJ[_app_id][idP] && xu_isEmpty(DOCS_OBJ[_app_id][idP])) {
         await func.utils.remove_cached_objects(SESSION_ID);
 

package/package.json

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