@bpmn-io/form-js-viewer 1.21.2 → 1.23.0

package/dist/index.cjs

@@ -376,7 +376,7 @@ class FeelersTemplating {
    * @param {Object} options
    * @param {boolean} [options.debug = false]
    * @param {boolean} [options.strict = false]
-   * @param {Function} [options.buildDebugString]
+   * @param {(error: Error) => string} [options.buildDebugString]
    * @param {Function} [options.sanitizer]
    *
    * @returns
@@ -403,20 +403,19 @@ class FeelersTemplating {
    */
 
   /**
-  * Extracts all feel expressions in the template along with their depth in the syntax tree.
-  * The depth is incremented for child expressions of loops to account for context drilling.
-  * @name extractExpressionsWithDepth
-  * @param {string} template - A feelers template string.
-  * @returns {Array<ExpressionWithDepth>} An array of objects, each containing the depth and the extracted expression.
-  *
-  * @example
-  * const template = "Hello {{user}}, you have:{{#loop items}}\n- {{amount}} {{name}}{{/loop}}.";
-  * const extractedExpressions = _extractExpressionsWithDepth(template);
-  */
+   * Extracts all feel expressions in the template along with their depth in the syntax tree.
+   * The depth is incremented for child expressions of loops to account for context drilling.
+    * @name _extractExpressionsWithDepth
+   * @param {string} template - A feelers template string.
+   * @returns {Array<ExpressionWithDepth>} An array of objects, each containing the depth and the extracted expression.
+   *
+   * @example
+   * const template = "Hello {{user}}, you have:{{#loop items}}\n- {{amount}} {{name}}{{/loop}}.";
+   * const extractedExpressions = _extractExpressionsWithDepth(template);
+   */
   _extractExpressionsWithDepth(template) {
     // build simplified feelers syntax tree
-    const parseTree = feelers.parser.parse(template);
-    const tree = feelers.buildSimpleTree(parseTree, template);
+    const tree = feelers.parseToSimpleTree(template);
     return function _traverse(n, depth = 0) {
       if (['Feel', 'FeelBlock'].includes(n.name)) {
         return [{
@@ -863,6 +862,50 @@ function runRecursively(formField, fn) {
   });
   fn(formField);
 }
+
+/**
+ * Returns a copy of `target` with the value at `path` removed, pruning any
+ * ancestor that becomes empty. Pure: the input is not mutated and untouched
+ * sibling branches keep their original references (path-cloning).
+ *
+ * Pruning rules:
+ *  - An object ancestor is removed when it has no own keys left.
+ *  - An array ancestor is removed when every entry is nullish. Arrays are
+ *    never compacted; `delete` leaves a sparse hole so sibling indexes stay
+ *    stable.
+ *
+ * @template T
+ * @param {T} target
+ * @param {Array<string|number>} path
+ * @returns {T}
+ */
+function pruneAt(target, path) {
+  if (!path.length) {
+    return target;
+  }
+  const cloneContainer = c => Array.isArray(c) ? c.slice() : {
+    ...c
+  };
+  const clones = [cloneContainer(target)];
+  for (let i = 0; i < path.length - 1; i++) {
+    const next = clones[i][path[i]];
+    if (next == null || typeof next !== 'object') {
+      return target;
+    }
+    const cloned = cloneContainer(next);
+    clones[i][path[i]] = cloned;
+    clones.push(cloned);
+  }
+  delete clones[clones.length - 1][path[path.length - 1]];
+  for (let i = clones.length - 1; i > 0; i--) {
+    if (Object.values(clones[i]).every(v => v == null)) {
+      delete clones[i - 1][path[i - 1]];
+    } else {
+      break;
+    }
+  }
+  return clones[0];
+}
 function wrapObjectKeysWithUnderscores(obj) {
   const newObj = {};
   for (const [key, value] of Object.entries(obj)) {
@@ -3786,6 +3829,11 @@ function willKeyProduceValidNumber(key, previousValue, caretIndex, selectionWidt
 function isNullEquivalentValue(value) {
   return value === undefined || value === null || value === '';
 }
+function serializeToInputString(value) {
+  if (value === undefined || value === null) return '';
+  if (typeof value !== 'string' && typeof value !== 'number') return '';
+  return value.toString();
+}
 
 const type$d = 'number';
 function Numberfield(props) {
@@ -3869,7 +3917,7 @@ function Numberfield(props) {
   const outerValueChanged = previousValue != value;
   const outerValueEqualsCache = sanitize(value) === sanitize(cachedValue);
   if (outerValueChanged && !outerValueEqualsCache) {
-    setValue(value && value.toString() || '');
+    setValue(serializeToInputString(value));
   }
 
   // caches the value an increment/decrement operation will be based on
@@ -7474,9 +7522,16 @@ class UpdateFieldInstanceValidationHandler {
     } = this._form._getState();
     context.oldErrors = clone(errors);
     const fieldErrors = this._validator.validateFieldInstance(fieldInstance, value);
-    const updatedErrors = minDash.set(errors, [id, ...Object.values(indexes || {})], fieldErrors.length ? fieldErrors : undefined);
+    const errorPath = [id, ...Object.values(indexes || {})];
+    let nextErrors;
+    if (fieldErrors.length) {
+      minDash.set(errors, errorPath, fieldErrors);
+      nextErrors = errors;
+    } else {
+      nextErrors = pruneAt(errors, errorPath);
+    }
     this._form._setState({
-      errors: updatedErrors
+      errors: nextErrors
     });
   }
   revert(context) {
@@ -9837,11 +9892,18 @@ class Form {
     const validator = this.get('validator');
     const fieldErrors = validator.validateFieldInstance(fieldInstance, value);
     minDash.set(data, valuePath, value);
-    minDash.set(errors, [id, ...Object.values(indexes || {})], fieldErrors.length ? fieldErrors : undefined);
+    const errorPath = [id, ...Object.values(indexes || {})];
+    let nextErrors;
+    if (fieldErrors.length) {
+      minDash.set(errors, errorPath, fieldErrors);
+      nextErrors = errors;
+    } else {
+      nextErrors = pruneAt(errors, errorPath);
+    }
     this._emit('field.updated', update);
     this._setState({
       data: clone(data),
-      errors: clone(errors)
+      errors: clone(nextErrors)
     });
   }
 
@@ -10107,6 +10169,7 @@ exports.iconsByType = iconsByType;
 exports.isRequired = isRequired;
 exports.pathParse = pathParse;
 exports.pathsEqual = pathsEqual;
+exports.pruneAt = pruneAt;
 exports.runExpressionEvaluation = runExpressionEvaluation;
 exports.runRecursively = runRecursively;
 exports.runUnaryTestEvaluation = runUnaryTestEvaluation;