@xuda.io/runtime-bundle 1.0.1437 → 1.0.1438

package/js/xuda-runtime-slim.min.es.js

@@ -1836,6 +1836,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 () {
@@ -7951,6 +8073,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]) {
@@ -7972,7 +8101,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];
     }
   }
 
@@ -7980,7 +8110,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);
 
@@ -17786,6 +17916,68 @@ const create_runtime_head_element = function (doc, tag_name, attributes, asset_k
   return node;
 };
 
+const queue_runtime_html_script_task = function (task) {
+  const queue =
+    func.runtime.render._html_script_queue ||
+    (func.runtime.render._html_script_queue = {
+      items: [],
+      scheduled: false,
+      running: false,
+    });
+
+  queue.items.push(task);
+
+  if (queue.scheduled || queue.running) {
+    return;
+  }
+
+  queue.scheduled = true;
+
+  const drain_queue = async function () {
+    if (queue.running) {
+      return;
+    }
+
+    queue.running = true;
+    queue.scheduled = false;
+
+    try {
+      while (queue.items.length) {
+        const next_task = queue.items.shift();
+        await next_task();
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      queue.running = false;
+      if (queue.items.length && !queue.scheduled) {
+        queue.scheduled = true;
+        schedule_runtime_html_script_queue();
+      }
+    }
+  };
+
+  const schedule_runtime_html_script_queue = function () {
+    const win = func.runtime.platform.get_window?.();
+    const run_later = function () {
+      setTimeout(function () {
+        drain_queue();
+      }, 0);
+    };
+
+    if (win?.requestAnimationFrame) {
+      win.requestAnimationFrame(function () {
+        win.requestAnimationFrame(run_later);
+      });
+      return;
+    }
+
+    run_later();
+  };
+
+  schedule_runtime_html_script_queue();
+};
+
 const upsert_runtime_head_element = async function (options) {
   const doc = func.runtime.platform.get_document?.();
   const head = doc?.head;
@@ -17899,19 +18091,21 @@ const render_runtime_html_asset = async function (options) {
       if (!src && !content.trim()) {
         return options.$container;
       }
-      await upsert_runtime_head_element({
-        tag_name,
-        attributes,
-        content,
-        asset_key,
-        signature,
-        find_existing_attr: src
-          ? {
-              name: 'src',
-              value: src,
-            }
-          : null,
-        await_load: !!src,
+      queue_runtime_html_script_task(async function () {
+        await upsert_runtime_head_element({
+          tag_name,
+          attributes,
+          content,
+          asset_key,
+          signature,
+          find_existing_attr: src
+            ? {
+                name: 'src',
+                value: src,
+              }
+            : null,
+          await_load: !!src,
+        });
       });
       return options.$container;
     }