@abgov/jsonforms-components 2.36.2 → 2.37.0

package/index.esm.js

@@ -13022,71 +13022,191 @@ function resolveScope(scope, data) {
   const cleaned = scope.replace(/^#\/(properties\/)?/, '');
   const parts = cleaned.split('/').filter(Boolean);
   let cur = data;
-  for (const p of parts) {
-    if (cur == null || typeof cur !== 'object') return undefined;
-    cur = cur[p];
+  for (const part of parts) {
+    if (cur == null) return undefined;
+    if (Array.isArray(cur) && /^\d+$/.test(part)) {
+      cur = cur[Number(part)];
+    } else if (typeof cur === 'object') {
+      if (part === 'properties') continue;
+      cur = cur[part];
+    } else {
+      return undefined;
+    }
   }
   return cur;
 }
-function sumColumn(scope, data) {
-  if (!scope || typeof scope !== 'string') return undefined;
-  // normalize scope: remove leading "#/" and optional "properties/"
+function evaluateSum(scope, data) {
+  if (!scope || typeof scope !== 'string') {
+    return {
+      value: undefined,
+      error: 'SUM() requires a JSON pointer argument.'
+    };
+  }
   const cleaned = scope.replace(/^#\/(properties\/)?/, '');
   const parts = cleaned.split('/').filter(Boolean);
-  if (parts.length < 2) return undefined;
-  const colKey = parts[parts.length - 1];
+  if (parts.length < 2) {
+    return {
+      value: undefined,
+      error: `SUM() pointer "${scope}" must include an array and field name.`
+    };
+  }
+  const fieldKey = parts[parts.length - 1];
   const arrPath = parts.slice(0, -1);
   let cur = data;
-  for (const p of arrPath) {
-    if (cur == null) return undefined;
-    // handle numeric indices for arrays
-    if (Array.isArray(cur) && /^\d+$/.test(p)) {
-      cur = cur[Number(p)];
+  for (const segment of arrPath) {
+    if (cur == null) {
+      cur = undefined;
+      break;
+    }
+    if (Array.isArray(cur) && /^\d+$/.test(segment)) {
+      cur = cur[Number(segment)];
+    } else if (typeof cur === 'object') {
+      if (segment === 'properties') continue;
+      cur = cur[segment];
     } else {
-      cur = cur[p];
+      cur = undefined;
+      break;
     }
   }
-  if (!Array.isArray(cur)) return undefined;
+  if (cur == null) {
+    return {
+      value: undefined,
+      error: `Please provide values for: ${scope}`
+    };
+  }
+  if (!Array.isArray(cur)) {
+    return {
+      value: undefined,
+      error: `SUM() pointer "${scope}" does not resolve to an array.`
+    };
+  }
+  const missingIndices = [];
+  const invalidIndices = [];
   let sum = 0;
-  for (const row of cur) {
-    if (row == null) return undefined;
-    const v = row[colKey];
-    if (typeof v !== 'number') return undefined;
-    sum += v;
+  for (let i = 0; i < cur.length; i++) {
+    const row = cur[i];
+    if (row == null || typeof row !== 'object') {
+      missingIndices.push(i);
+      continue;
+    }
+    const v = row[fieldKey];
+    if (v === undefined || v === null || v === '') {
+      missingIndices.push(i);
+    } else if (typeof v !== 'number' || Number.isNaN(v)) {
+      invalidIndices.push(i);
+    } else {
+      sum += v;
+    }
+  }
+  if (invalidIndices.length > 0) {
+    return {
+      value: undefined,
+      error: `Expected numeric values for: ${scope} at rows [${invalidIndices.join(', ')}]`
+    };
   }
-  return sum;
+  if (missingIndices.length === cur.length) {
+    return {
+      value: undefined,
+      error: `Please provide values for: ${scope}`
+    };
+  }
+  return {
+    value: sum,
+    error: missingIndices.length ? `Some rows are missing values for: ${scope}` : undefined
+  };
 }
+/**
+ * General expression evaluation.
+ * - Supports SUM(#/properties/arr/c3)
+ * - Supports arithmetic with JSON pointers:
+ *   "#/properties/x * #/properties/y + #/properties/z"
+ *
+ * Returns { value, error } and NEVER throws.
+ */
 function evaluateExpression(expression, data) {
-  if (!expression || typeof expression !== 'string') return undefined;
+  if (!expression || typeof expression !== 'string') {
+    return {
+      value: undefined,
+      error: undefined
+    };
+  }
   const trimmed = expression.trim();
+  if (!trimmed) return {
+    value: undefined,
+    error: undefined
+  };
   const sumMatch = trimmed.match(/^SUM\(\s*['"]?(.+?)['"]?\s*\)$/i);
   if (sumMatch) {
-    return sumColumn(sumMatch[1], data);
+    const pointer = sumMatch[1];
+    return evaluateSum(pointer, data);
   }
-  // Find unique scope tokens like #/properties/x or #/arr/0/c3
   const scopeRegex = /#\/(?:properties\/)?[^\s"')]+/g;
   const matches = trimmed.match(scopeRegex) || [];
   const uniqueScopes = Array.from(new Set(matches));
-  // Prepare variable mapping for expr-eval
+  let exprForParse = trimmed;
+  const scopeToVar = new Map();
+  uniqueScopes.forEach((scope, index) => {
+    const varName = `v${index}`;
+    scopeToVar.set(scope, varName);
+    const pattern = new RegExp(`['"]?${escapeRegExp(scope)}['"]?`, 'g');
+    exprForParse = exprForParse.replace(pattern, varName);
+  });
+  let parsed;
+  try {
+    const parser = new Parser();
+    parsed = parser.parse(exprForParse);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (e) {
+    return {
+      value: undefined,
+      error: 'Invalid expression syntax'
+    };
+  }
   const vars = {};
-  let expr = trimmed;
-  for (let i = 0; i < uniqueScopes.length; i++) {
-    const scope = uniqueScopes[i];
+  const missingScopes = [];
+  const invalidTypeScopes = [];
+  for (const scope of uniqueScopes) {
     const val = resolveScope(scope, data);
-    if (val === undefined || typeof val !== 'number') return undefined;
-    const varName = `v${i}`;
+    if (val === undefined || val === null || val === '') {
+      missingScopes.push(scope);
+      continue;
+    }
+    if (typeof val !== 'number' || Number.isNaN(val)) {
+      invalidTypeScopes.push(scope);
+      continue;
+    }
+    const varName = scopeToVar.get(scope);
     vars[varName] = val;
-    const pattern = new RegExp(`['"]?${escapeRegExp(scope)}['"]?`, 'g');
-    expr = expr.replace(pattern, varName);
   }
-  // Evaluate with expr-eval parser
+  if (invalidTypeScopes.length > 0) {
+    return {
+      value: undefined,
+      error: `Expected numeric values for: ${invalidTypeScopes.join(', ')}`
+    };
+  }
+  if (missingScopes.length > 0) {
+    return {
+      value: undefined,
+      error: `Please provide values for: ${missingScopes.join(', ')}`
+    };
+  }
   try {
-    const parser = new Parser();
-    const parsed = parser.parse(expr);
     const result = parsed.evaluate(vars);
-    return typeof result === 'number' && Number.isFinite(result) ? result : undefined;
+    if (typeof result === 'number' && Number.isFinite(result)) {
+      return {
+        value: result,
+        error: undefined
+      };
+    }
+    return {
+      value: undefined,
+      error: 'Expression did not produce a numeric result'
+    };
   } catch (_a) {
-    return undefined;
+    return {
+      value: undefined,
+      error: 'Error while evaluating expression'
+    };
   }
 }
 
@@ -13094,29 +13214,44 @@ const GoACalculation = props => {
   var _a;
   const {
     uischema,
-    data,
     schema,
     path,
     id,
     visible,
     handleChange
   } = props;
-  const expression = schema === null || schema === void 0 ? void 0 : schema.description;
   const label = typeof (uischema === null || uischema === void 0 ? void 0 : uischema.label) === 'string' ? uischema.label : undefined;
+  const expression = schema === null || schema === void 0 ? void 0 : schema.description;
   const {
     core
   } = useJsonForms();
   const rootData = (_a = core === null || core === void 0 ? void 0 : core.data) !== null && _a !== void 0 ? _a : {};
-  const computedValue = expression ? evaluateExpression(expression, rootData) : undefined;
-  React.useEffect(() => {
+  const [hasInteracted, setHasInteracted] = useState(false);
+  const prevDataRef = useRef(rootData);
+  useEffect(() => {
+    setHasInteracted(was => was ? true : true);
+  }, [rootData]);
+  useEffect(() => {
+    if (prevDataRef.current !== rootData) {
+      setHasInteracted(true);
+      prevDataRef.current = rootData;
+    }
+  }, [rootData]);
+  const {
+    value: computedValue,
+    error
+  } = evaluateExpression(expression, rootData);
+  useEffect(() => {
     if (computedValue !== undefined && typeof handleChange === 'function' && path) {
       handleChange(path, computedValue);
     }
   }, [computedValue, handleChange, path]);
+  const showError = hasInteracted && !!error;
   return jsx(Visible, {
     visible: visible,
     children: jsx(GoAFormItem, {
       label: label,
+      error: showError ? error : '',
       children: jsx(GoAInput, {
         name: `computed-input-${id}`,
         testId: `computed-input-${id}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abgov/jsonforms-components",
-  "version": "2.36.2",
+  "version": "2.37.0",
   "license": "Apache-2.0",
   "description": "Government of Alberta - React renderers for JSON Forms based on the design system.",
   "repository": "https://github.com/GovAlta/adsp-monorepo",

package/src/lib/Controls/Calculation/CalculationEngine.d.ts

@@ -1,3 +1,15 @@
+export interface EvaluationResult {
+    value?: number;
+    error?: string;
+}
 export declare function resolveScope(scope: string, data: unknown): unknown;
-export declare function sumColumn(scope: string, data: unknown): number | undefined;
-export declare function evaluateExpression(expression: string, data: unknown): number | undefined;
+export declare function evaluateSum(scope: string | undefined, data: unknown): EvaluationResult;
+/**
+ * General expression evaluation.
+ * - Supports SUM(#/properties/arr/c3)
+ * - Supports arithmetic with JSON pointers:
+ *   "#/properties/x * #/properties/y + #/properties/z"
+ *
+ * Returns { value, error } and NEVER throws.
+ */
+export declare function evaluateExpression(expression: string | undefined, data: unknown): EvaluationResult;