@xuda.io/runtime-bundle 1.0.1429 → 1.0.1431

package/js/xuda-runtime-bundle.js

@@ -36695,7 +36695,7 @@ func.runtime.render.handle_xu_bind = async function (options) {
 };
 func.runtime.render.apply_xu_class = async function (options) {
   try {
-    const classes_obj = typeof options.val.value === 'string' ? JSON.parse(options.val.value) : Object.assign({}, {}, options.val.value);
+    const classes_obj = typeof options.val.value === 'string' ? JSON5.parse(options.val.value) : Object.assign({}, {}, options.val.value);
     const xuData = func.runtime.ui.get_data(options.$elm)?.xuData;
     const class_names = Object.keys(classes_obj);
 
@@ -36725,7 +36725,18 @@ func.runtime.render.apply_xu_class = async function (options) {
     xuData.debug_info.attribute_stat['xu-class'] = func.runtime.ui.get_first_node(options.$elm)?.className || func.runtime.ui.get_attr(options.$elm, 'class');
     return {};
   } catch (e) {
-    console.warn('parse error:' + options.val.value);
+    await func.runtime.render.report_xu_runtime_error(
+      {
+        ...options,
+        xu_func: 'xu-class',
+        val: {
+          key: 'xu-class',
+          value: options?.val?.value,
+        },
+      },
+      e,
+      'xu-class has invalid object syntax',
+    );
     return { abort: true };
   }
 };
@@ -37406,14 +37417,43 @@ func.runtime.widgets = func.runtime.widgets || {};
 // Browser-only common xu handler factories live here so registry composition can stay small.
 
 func.runtime.render.build_base_xu_handlers = function (options, _ds) {
+  const parse_object_value = function (attr_name, val, shape = 'object') {
+    let parsed_value = val?.value;
+    if (typeof parsed_value === 'string') {
+      try {
+        parsed_value = JSON5.parse(parsed_value);
+      } catch (error) {
+        throw func.runtime.render.build_xu_runtime_error(
+          { ...options, xu_func: attr_name, val: { key: attr_name, value: val?.value } },
+          error,
+          `${attr_name} has invalid ${shape} syntax`,
+        );
+      }
+    }
+
+    const valid =
+      shape === 'array'
+        ? Array.isArray(parsed_value)
+        : typeof parsed_value === 'object' && parsed_value !== null && !Array.isArray(parsed_value);
+
+    if (!valid) {
+      throw func.runtime.render.build_xu_runtime_error(
+        { ...options, xu_func: attr_name, val: { key: attr_name, value: val?.value } },
+        null,
+        `${attr_name} expects a ${shape} value`,
+      );
+    }
+
+    return parsed_value;
+  };
   return {
     'xu-attrs': async function ($elm, val) {
       if (!val.value) return {};
-      if (!(typeof val.value === 'object' && val.value !== null)) throw 'xu-attrs value us not an object';
-      const attr_keys = Object.keys(val.value);
+      const attrs_obj = parse_object_value('xu-attrs', val, 'object');
+      const attr_keys = Object.keys(attrs_obj);
       for (let index = 0; index < attr_keys.length; index++) {
         const attr_key = attr_keys[index];
-        options.nodeP.attributes[attr_key] = val.value[attr_key];
+        options.nodeP.attributes[attr_key] = attrs_obj[attr_key];
       }
       return {};
     },
@@ -37533,7 +37573,7 @@ func.runtime.render.build_base_xu_handlers = function (options, _ds) {
       return {};
     },
     'xu-cdn': async function ($elm, val) {
-      const resources_obj = val.value || {};
+      const resources_obj = parse_object_value('xu-cdn', val, 'object');
       const resource_keys = Object.keys(resources_obj);
       for (let index = 0; index < resource_keys.length; index++) {
         const resource = resources_obj[resource_keys[index]];
@@ -37542,7 +37582,7 @@ func.runtime.render.build_base_xu_handlers = function (options, _ds) {
       return {};
     },
     'xu-ui-plugin': async function ($elm, val) {
-      const plugins_obj = val.value || {};
+      const plugins_obj = parse_object_value('xu-ui-plugin', val, 'object');
       const plugin_names = Object.keys(plugins_obj);
       for (let index = 0; index < plugin_names.length; index++) {
         const plugin_name = plugin_names[index];
@@ -37553,14 +37593,14 @@ func.runtime.render.build_base_xu_handlers = function (options, _ds) {
     },
     'xu-store': async function ($elm, val) {
       try {
-        const fields_obj = JSON5.parse(val.value);
+        const fields_obj = parse_object_value('xu-store', val, 'object');
         const field_ids = Object.keys(fields_obj);
         for (let index = 0; index < field_ids.length; index++) {
           const field_id = field_ids[index];
           func.datasource.add_dynamic_field_to_ds(options.SESSION_ID, options.paramsP.dsSessionP, field_id, fields_obj[field_id]);
         }
       } catch (err) {
-        console.error(err);
+        throw err;
       }
       return {};
     },
@@ -37683,6 +37723,36 @@ func.runtime.render = func.runtime.render || {};
 func.runtime.widgets = func.runtime.widgets || {};
 
 // Browser-only xu-attribute dispatch lives here so the attribute phase engine can stay focused.
+func.runtime.render.build_xu_runtime_error = function (options, error, fallback_message) {
+  const raw_message = error?.message || error || fallback_message || 'Unknown runtime error';
+  const err = error instanceof Error ? error : new Error(raw_message);
+  err.xu_func = options?.xu_func;
+  err.node_tag = options?.nodeP?.tagName;
+  err.raw_value = options?.val?.value;
+  err.ui_id = func.runtime?.ui?.get_attr ? func.runtime.ui.get_attr(options?.$elm, 'xu-ui-id') : null;
+  return err;
+};
+func.runtime.render.report_xu_runtime_error = async function (options, error, fallback_message) {
+  const err = func.runtime.render.build_xu_runtime_error(options, error, fallback_message);
+  const attr_name = options?.val?.key || options?.xu_func || 'xu-*';
+  const tag_name = options?.nodeP?.tagName || 'unknown';
+  const raw_value = typeof err.raw_value === 'string' ? err.raw_value : JSON.stringify(err.raw_value);
+  const message = [`${attr_name} failed on <${tag_name}>`, err.message];
+
+  if (raw_value) {
+    message.push(`Value: ${raw_value}`);
+  }
+
+  if (err.ui_id) {
+    message.push(`xu-ui-id: ${err.ui_id}`);
+  }
+
+  console.error('XUDA RUNTIME', message.join(' | '), err);
+  if (func.utils?.debug_report) {
+    await func.utils.debug_report(options?.SESSION_ID, 'Slim runtime', message.join(' | '), 'E', err);
+  }
+  return {};
+};
 func.runtime.render.execute_xu_function = async function (options) {
   if (options.is_skeleton) return;
 
@@ -37714,13 +37784,13 @@ func.runtime.render.execute_xu_function = async function (options) {
 
   try {
     if (!common_fx[options.xu_func]) {
-      console.warn('invalid xu-tag', options.xu_func);
+      await func.runtime.render.report_xu_runtime_error(options, null, `Unknown xu directive: ${options.xu_func}`);
       return {};
     }
 
     return await common_fx[options.xu_func](options.$elm, options.val);
   } catch (error) {
-    debugger;
+    return await func.runtime.render.report_xu_runtime_error(options, error);
   }
 };
  func.datasource = {};
@@ -40128,6 +40198,38 @@ func.datasource.get_viewFields_for_update_function = function (SESSION_ID, calli
   return viewFields;
 };
 func.datasource.get_value = async function (SESSION_ID, fieldIdP, dsSessionP, rowIdP, org_dsSessionP) {
+  const normalize_field_id = function (field_id) {
+    if (typeof field_id === 'string') {
+      return field_id;
+    }
+    if (typeof field_id?.field_id === 'string') {
+      return field_id.field_id;
+    }
+    if (typeof field_id?.id === 'string') {
+      return field_id.id;
+    }
+    if (typeof field_id === 'number' || typeof field_id === 'boolean' || typeof field_id === 'bigint') {
+      return field_id.toString();
+    }
+    const coerced = field_id?.toString?.();
+    if (typeof coerced === 'string' && coerced && coerced !== '[object Object]') {
+      return coerced;
+    }
+    return null;
+  };
+  const return_missing_value = function (field_id, currentRecordId = null) {
+    return {
+      ret: {
+        value: undefined,
+        type: 'string',
+        prop: null,
+      },
+      dsSessionP,
+      fieldIdP: field_id,
+      currentRecordId,
+      found: false,
+    };
+  };
   const return_value = async (field_id, value) => {
     const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSessionP);
     let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
@@ -40256,9 +40358,21 @@ func.datasource.get_value = async function (SESSION_ID, fieldIdP, dsSessionP, ro
       // let prev_ds = dsSessionP - 1;
       return await func.datasource.get_value(SESSION_ID, fieldIdP, dsSessionP - 1, rowIdP, org_dsSessionP);
     }
+    const normalized_missing_field = normalize_field_id(fieldIdP);
+    if (normalized_missing_field === null) {
+      return return_missing_value(fieldIdP);
+    }
+    fieldIdP = normalized_missing_field;
     return await return_value(fieldIdP);
   } //console.error("error: datasource not exist: " + dsSessionP);
 
+  const normalized_field_id = normalize_field_id(fieldIdP);
+  if (normalized_field_id === null) {
+    func.utils.debug_report(SESSION_ID, 'Datasource get value', `Invalid field id type: ${typeof fieldIdP}`, 'W');
+    return return_missing_value(fieldIdP, _ds.currentRecordId);
+  }
+  fieldIdP = normalized_field_id;
+
   let recordId = rowIdP;
   if (!recordId) {
     recordId = _ds.currentRecordId;