@xuda.io/xuda-worker-bundle 1.3.2693 → 1.3.2695

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();
@@ -610,6 +679,147 @@ func.runtime.workers.delete_promise = function (SESSION_ID, worker_id, promise_q
   delete registry_entry.promise_queue[promise_queue_id];
   return true;
 };
+func.runtime.render.clone_runtime_options = function (value) {
+  if (typeof structuredClone === 'function') {
+    try {
+      return structuredClone(value);
+    } catch (_) {}
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(function (item) {
+      return func.runtime.render.clone_runtime_options(item);
+    });
+  }
+
+  if (value && typeof value === 'object') {
+    const cloned = {};
+    const keys = Object.keys(value);
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      cloned[key] = func.runtime.render.clone_runtime_options(value[key]);
+    }
+    return cloned;
+  }
+
+  return value;
+};
+func.runtime.render.normalize_runtime_bootstrap = function (raw_options = {}) {
+  const options = raw_options || {};
+  let app_computing_mode = options.app_computing_mode || '';
+  let app_render_mode = options.app_render_mode || '';
+  let app_client_activation = options.app_client_activation || '';
+  let ssr_payload = options.ssr_payload || null;
+
+  if (typeof ssr_payload === 'string') {
+    try {
+      ssr_payload = JSON.parse(ssr_payload);
+    } catch (_) {
+      ssr_payload = null;
+    }
+  }
+
+  if (ssr_payload && typeof ssr_payload === 'object') {
+    ssr_payload = func.runtime.render.clone_runtime_options(ssr_payload);
+  }
+
+  if (!app_computing_mode) {
+    if (app_render_mode === 'ssr_first_page' || app_render_mode === 'ssr_full') {
+      app_computing_mode = 'server';
+    } else {
+      app_computing_mode = 'main';
+    }
+  }
+
+  switch (app_computing_mode) {
+    case 'main':
+      app_render_mode = 'csr';
+      app_client_activation = 'none';
+      break;
+
+    case 'worker':
+      app_render_mode = 'csr';
+      app_client_activation = 'none';
+      break;
+
+    default:
+      app_computing_mode = 'server';
+      if (app_render_mode !== 'ssr_full') {
+        app_render_mode = 'ssr_first_page';
+      }
+      app_client_activation = app_render_mode === 'ssr_full' ? 'hydrate' : 'takeover';
+      break;
+  }
+
+  if (ssr_payload && typeof ssr_payload === 'object') {
+    if (!ssr_payload.app_render_mode) {
+      ssr_payload.app_render_mode = app_render_mode;
+    }
+    if (!ssr_payload.app_client_activation) {
+      ssr_payload.app_client_activation = app_client_activation;
+    }
+    if (!ssr_payload.app_computing_mode) {
+      ssr_payload.app_computing_mode = app_computing_mode;
+    }
+  }
+
+  return {
+    app_computing_mode,
+    app_render_mode,
+    app_client_activation,
+    ssr_payload,
+  };
+};
+func.runtime.render.apply_runtime_bootstrap_defaults = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target);
+  target.app_computing_mode = normalized.app_computing_mode;
+  target.app_render_mode = normalized.app_render_mode;
+  target.app_client_activation = normalized.app_client_activation;
+  target.ssr_payload = normalized.ssr_payload;
+  return normalized;
+};
+func.runtime.render.is_server_render_mode = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target?.opt || target);
+  return normalized.app_computing_mode === 'server' && normalized.app_render_mode !== 'csr';
+};
+func.runtime.render.is_takeover_mode = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target?.opt || target);
+  return normalized.app_client_activation === 'takeover';
+};
+func.runtime.render.is_hydration_mode = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target?.opt || target);
+  return normalized.app_client_activation === 'hydrate';
+};
+func.runtime.render.get_ssr_payload = function (target = {}) {
+  if (target?.opt?.ssr_payload) {
+    return target.opt.ssr_payload;
+  }
+  if (target?.ssr_payload) {
+    return target.ssr_payload;
+  }
+  const win = func.runtime.platform.get_window();
+  return win?.__XUDA_SSR__ || null;
+};
+func.runtime.render.should_use_ssr_payload = function (SESSION_ID, paramsP) {
+  const session = SESSION_OBJ?.[SESSION_ID];
+  const payload = func.runtime.render.get_ssr_payload(session);
+  if (!payload || payload._consumed) {
+    return false;
+  }
+  if (paramsP?.prog_id && payload.prog_id && payload.prog_id !== paramsP.prog_id) {
+    return false;
+  }
+  return true;
+};
+func.runtime.render.mark_ssr_payload_consumed = function (SESSION_ID) {
+  const session = SESSION_OBJ?.[SESSION_ID];
+  const payload = func.runtime.render.get_ssr_payload(session);
+  if (!payload || typeof payload !== 'object') {
+    return false;
+  }
+  payload._consumed = true;
+  return true;
+};
 func.runtime.render.get_root_data_system = function (SESSION_ID) {
   return SESSION_OBJ[SESSION_ID]?.DS_GLB?.[0]?.data_system || null;
 };
@@ -1013,10 +1223,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);
@@ -2914,6 +3124,129 @@ func.runtime.render.render_to_string = async function (options = {}) {
   });
 
   return await func.runtime.render.render_tree_to_string(treeP, options);
+};
+func.runtime.render.get_server_render_mode = function (options = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap({
+    app_computing_mode: options.app_computing_mode,
+    app_render_mode: options.app_render_mode,
+    app_client_activation: options.app_client_activation,
+  });
+
+  return normalized;
+};
+func.runtime.render.build_server_render_params = async function (options = {}) {
+  const SESSION_ID = options.SESSION_ID;
+  const prog_id = options.prog_id;
+  const dsSessionP = options.dsSessionP;
+  const _session = SESSION_OBJ?.[SESSION_ID] || {};
+  const _ds = _session?.DS_GLB?.[dsSessionP] || {};
+  const viewDoc = options.viewDoc || (await func.utils?.VIEWS_OBJ?.get?.(SESSION_ID, prog_id));
+
+  if (!viewDoc?.properties) {
+    throw new Error(`view document not found for ${prog_id}`);
+  }
+
+  const base_params = _ds?.screen_params ? func.runtime.render.safe_clone_tree_value(_ds.screen_params) : {};
+  const screenId = options.screenId || base_params.screenId || `ssr_${prog_id}_${dsSessionP || '0'}`;
+  const paramsP = {
+    ...base_params,
+    prog_id,
+    sourceScreenP: null,
+    $callingContainerP: null,
+    triggerIdP: null,
+    callingDataSource_objP: _ds,
+    rowIdP: typeof options.rowIdP !== 'undefined' ? options.rowIdP : (_ds?.currentRecordId || null),
+    renderType: viewDoc.properties?.renderType,
+    parameters_obj_inP: options.parameters_obj_inP || base_params.parameters_obj_inP || options.parameters_raw_obj || {},
+    source_functionP: options.source_functionP || base_params.source_functionP || 'render_string',
+    is_panelP: false,
+    screen_type: options.screen_type || base_params.screen_type || 'render_string',
+    screenInfo: viewDoc,
+    call_screen_propertiesP: base_params.call_screen_propertiesP,
+    parentDataSourceNoP: typeof _ds?.parentDataSourceNo === 'undefined' || _ds?.parentDataSourceNo === null ? 0 : _ds.parentDataSourceNo,
+    parameters_raw_obj: options.parameters_raw_obj || base_params.parameters_raw_obj || {},
+    dsSessionP,
+    screenId,
+    containerIdP: base_params.containerIdP || `ssr_container_${screenId}`,
+  };
+
+  if (_ds) {
+    _ds.screen_params = paramsP;
+  }
+
+  return paramsP;
+};
+func.runtime.render.build_prog_tree = async function (options = {}) {
+  const SESSION_ID = options.SESSION_ID;
+  const prog_id = options.prog_id;
+  const viewDoc = options.viewDoc || (await func.utils?.VIEWS_OBJ?.get?.(SESSION_ID, prog_id));
+
+  if (!viewDoc?.progUi?.length) {
+    throw new Error(`progUi not found for ${prog_id}`);
+  }
+
+  const paramsP = options.paramsP || (await func.runtime.render.build_server_render_params({
+    ...options,
+    SESSION_ID,
+    prog_id,
+    viewDoc,
+  }));
+  const root_index = typeof options.root_index === 'number' ? options.root_index : 0;
+  const root_node = func.runtime.render.safe_clone_tree_value(viewDoc.progUi[root_index]);
+  const tree = await func.runtime.render.build_tree({
+    SESSION_ID,
+    nodeP: root_node,
+    paramsP,
+  });
+
+  return {
+    tree,
+    paramsP,
+    viewDoc,
+  };
+};
+func.runtime.render.build_ssr_payload = function (render_program, options = {}) {
+  const runtime_profile = func.runtime.render.get_server_render_mode(options);
+  return {
+    contract: 'xuda.ssr.v1',
+    prog_id: options.prog_id,
+    screenId: render_program.paramsP.screenId,
+    containerId: render_program.paramsP.containerIdP,
+    app_computing_mode: runtime_profile.app_computing_mode,
+    app_render_mode: runtime_profile.app_render_mode,
+    app_client_activation: runtime_profile.app_client_activation,
+    tree_contract: func.runtime.render.TREE_CONTRACT_VERSION,
+  };
+};
+func.runtime.render.build_ssr_screen_html = function (html, render_program, options = {}) {
+  const payload = func.runtime.render.build_ssr_payload(render_program, options);
+  const screenId = func.runtime.render.escape_html_attribute(payload.screenId || '');
+  const containerId = func.runtime.render.escape_html_attribute(payload.containerId || '');
+  const activation = func.runtime.render.escape_html_attribute(payload.app_client_activation || 'takeover');
+
+  return `<div data-xuda-ssr-embed="true" class="xu_embed_div"><div id="${screenId}" class="xu_embed_container" data-xuda-ssr-screen="true" data-xuda-ssr-screen-id="${screenId}" data-xuda-activation="${activation}" style="display: contents;"><div id="${containerId}" data-xuda-ssr-root-frame="true" data-xuda-ssr-screen-id="${screenId}" data-xuda-activation="${activation}" style="display: contents;">${html}</div></div></div>`;
+};
+func.runtime.render.render_prog_to_string = async function (options = {}) {
+  const render_program = await func.runtime.render.build_prog_tree(options);
+  const html = await func.runtime.render.render_to_string({
+    ...options,
+    SESSION_ID: options.SESSION_ID,
+    treeP: render_program.tree,
+    paramsP: render_program.paramsP,
+  });
+  const ssr_payload = func.runtime.render.build_ssr_payload(render_program, options);
+  const screen_html = func.runtime.render.build_ssr_screen_html(html, render_program, options);
+
+  return {
+    prog_id: options.prog_id,
+    dsSessionP: render_program.paramsP.dsSessionP,
+    screenId: render_program.paramsP.screenId,
+    html,
+    screen_html,
+    tree_json: func.runtime.render.serialize_tree(render_program.tree),
+    paramsP: render_program.paramsP,
+    ssr_payload,
+  };
 };
  glb.DEBUG_INFO_OBJ = {};
 // var CONNECTION_ATTEMPTS = 0;

package/package.json

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