@bpmn-io/form-js-editor 0.6.1 → 0.7.2

package/dist/index.cjs

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var formJsViewer = require('@bpmn-io/form-js-viewer');
 var Ids = require('ids');
 var minDash = require('min-dash');
-var formJsViewer = require('@bpmn-io/form-js-viewer');
 var preact = require('preact');
 var hooks$1 = require('preact/hooks');
 var React = require('preact/compat');
@@ -1165,7 +1165,7 @@ function TextInput(props) {
   const prevValue = usePrevious(value);
   const [cachedValue, setCachedValue] = hooks$1.useState(null);
   const [error, setError] = hooks$1.useState(null);
-  hooks$1.useEffect(() => setError(validate(value)), [value]);
+  hooks$1.useEffect(() => setError(validate(value)), [validate, value]);
   const onInput = useDebounce(event => {
     const value = event.target.value;
     const error = validate(value);
@@ -1679,7 +1679,7 @@ function DisabledEntry(props) {
   } = props;
 
   const onChange = value => {
-    editField(field, 'disabled', value);
+    editField(field, ['disabled'], value);
   };
 
   return jsxRuntime.jsx(CheckboxInputEntry, {
@@ -1815,9 +1815,18 @@ function ValueEntry(props) {
   const {
     editField,
     field,
-    index
+    index,
+    validate
   } = props;
 
+  const getLabel = () => {
+    return minDash.get(field, ['values', index, 'label']);
+  };
+
+  const getValue = () => {
+    return minDash.get(field, ['values', index, 'value']);
+  };
+
   const onChange = key => {
     const values = minDash.get(field, ['values']);
     return value => {
@@ -1830,14 +1839,93 @@ function ValueEntry(props) {
       id: `value-label-${index}`,
       label: "Label",
       onChange: onChange('label'),
-      value: minDash.get(field, ['values', index, 'label'])
+      value: getLabel()
+    }), jsxRuntime.jsx(TextInputEntry, {
+      id: `value-value-${index}`,
+      label: "Value",
+      onChange: onChange('value'),
+      value: getValue(),
+      validate: validate(getValue())
+    })]
+  });
+}
+
+function CustomValueEntry(props) {
+  const {
+    editField,
+    field,
+    index,
+    validate
+  } = props;
+
+  const getKey = () => {
+    return Object.keys(minDash.get(field, ['properties']))[index];
+  };
+
+  const getValue = () => {
+    return minDash.get(field, ['properties', getKey()]);
+  };
+
+  const onChange = key => {
+    const properties = minDash.get(field, ['properties']);
+    return value => {
+      if (key === 'value') {
+        editField(field, 'properties', updateValue(properties, getKey(), value));
+      } else if (key === 'key') {
+        editField(field, 'properties', updateKey(properties, getKey(), value));
+      }
+    };
+  };
+
+  return jsxRuntime.jsxs(jsxRuntime.Fragment, {
+    children: [jsxRuntime.jsx(TextInputEntry, {
+      id: `value-key-${index}`,
+      label: "Key",
+      onChange: onChange('key'),
+      value: getKey(),
+      validate: validate(getKey())
     }), jsxRuntime.jsx(TextInputEntry, {
       id: `value-value-${index}`,
       label: "Value",
       onChange: onChange('value'),
-      value: minDash.get(field, ['values', index, 'value'])
+      value: getValue()
     })]
   });
+} // helpers //////////
+
+/**
+ * Returns copy of object with updated value.
+ *
+ * @param {Object} properties
+ * @param {string} key
+ * @param {string} value
+ *
+ * @returns {Object}
+ */
+
+function updateValue(properties, key, value) {
+  return { ...properties,
+    [key]: value
+  };
+}
+/**
+ * Returns copy of object with updated key.
+ *
+ * @param {Object} properties
+ * @param {string} oldKey
+ * @param {string} newKey
+ *
+ * @returns {Object}
+ */
+
+
+function updateKey(properties, oldKey, newKey) {
+  return Object.entries(properties).reduce((newProperties, entry) => {
+    const [key, value] = entry;
+    return { ...newProperties,
+      [key === oldKey ? newKey : key]: value
+    };
+  }, {});
 }
 
 function GeneralGroup(field, editField) {
@@ -1948,10 +2036,10 @@ function ValidationGroup(field, editField) {
       onChange: onChange('maxLength'),
       value: minDash.get(field, ['validate', 'maxLength'])
     }), jsxRuntime.jsx(TextInputEntry, {
-      id: "regularExpressionPattern",
+      id: "pattern",
       label: "Regular Expression Pattern",
-      onChange: onChange('regularExpressionPattern'),
-      value: minDash.get(field, ['validate', 'regularExpressionPattern'])
+      onChange: onChange('pattern'),
+      value: minDash.get(field, ['validate', 'pattern'])
     }));
   }
 
@@ -1982,13 +2070,32 @@ function ValuesGroup(field, editField) {
   } = field;
 
   const addEntry = () => {
+    const index = values.length + 1;
     const entry = {
-      label: 'Value',
-      value: 'value'
+      label: `Value ${index}`,
+      value: `value${index}`
     };
     editField(field, ['values'], arrayAdd$1(values, values.length, entry));
   };
 
+  const validateFactory = key => {
+    return value => {
+      if (value === key) {
+        return;
+      }
+
+      if (minDash.isUndefined(value) || !value.length) {
+        return 'Must not be empty.';
+      }
+
+      const isValueAssigned = values.find(entry => entry.value === value);
+
+      if (isValueAssigned) {
+        return 'Must be unique.';
+      }
+    };
+  };
+
   const hasEntries = values.length > 0;
   return jsxRuntime.jsx(Group, {
     label: "Values",
@@ -2009,13 +2116,92 @@ function ValuesGroup(field, editField) {
         children: jsxRuntime.jsx(ValueEntry, {
           editField: editField,
           field: field,
-          index: index
+          index: index,
+          validate: validateFactory
         })
       }, `${id}-${index}`);
     })
   });
 }
 
+function CustomValuesGroup(field, editField) {
+  const {
+    id,
+    properties = {}
+  } = field;
+
+  const addEntry = () => {
+    const index = Object.keys(properties).length + 1;
+    const key = `key${index}`,
+          value = 'value';
+    editField(field, ['properties'], { ...properties,
+      [key]: value
+    });
+  };
+
+  const validateFactory = key => {
+    return value => {
+      if (value === key) {
+        return;
+      }
+
+      if (minDash.isUndefined(value) || !value.length) {
+        return 'Must not be empty.';
+      }
+
+      if (minDash.has(properties, value)) {
+        return 'Must be unique.';
+      }
+    };
+  };
+
+  const hasEntries = Object.keys(properties).length > 0;
+  return jsxRuntime.jsx(Group, {
+    label: "Custom Properties",
+    addEntry: addEntry,
+    hasEntries: hasEntries,
+    children: Object.keys(properties).map((key, index) => {
+      const removeEntry = () => {
+        editField(field, ['properties'], removeKey(properties, key));
+      };
+
+      return jsxRuntime.jsx(CollapsibleEntry, {
+        label: key,
+        removeEntry: removeEntry,
+        children: jsxRuntime.jsx(CustomValueEntry, {
+          editField: editField,
+          field: field,
+          index: index,
+          validate: validateFactory
+        })
+      }, `${id}-${index}`);
+    })
+  });
+} // helpers //////////
+
+/**
+ * Returns copy of object without key.
+ *
+ * @param {Object} properties
+ * @param {string} oldKey
+ *
+ * @returns {Object}
+ */
+
+function removeKey(properties, oldKey) {
+  return Object.entries(properties).reduce((newProperties, entry) => {
+    const [key, value] = entry;
+
+    if (key === oldKey) {
+      return newProperties;
+    }
+
+    return { ...newProperties,
+      [key]: value
+    };
+  }, {});
+}
+
 const labelsByType = {
   button: 'BUTTON',
   checkbox: 'CHECKBOX',
@@ -2042,6 +2228,10 @@ function getGroups(field, editField) {
     groups.push(ValidationGroup(field, editField));
   }
 
+  if (type !== 'default') {
+    groups.push(CustomValuesGroup(field, editField));
+  }
+
   return groups;
 }
 
@@ -4475,6 +4665,10 @@ const ids = new Ids__default['default']([32, 36, 1]);
  *   properties: FormEditorProperties,
  *   schema: Schema
  * } } State
+ *
+ * @typedef { (type:string, priority:number, handler:Function) => void } OnEventWithPriority
+ * @typedef { (type:string, handler:Function) => void } OnEventWithOutPriority
+ * @typedef { OnEventWithPriority & OnEventWithOutPriority } OnEventType
  */
 
 /**
@@ -4487,10 +4681,16 @@ class FormEditor {
    * @param {FormEditorOptions} options
    */
   constructor(options = {}) {
+    /**
+     * @public
+     * @type {OnEventType}
+     */
+    this.on = this._onEvent;
     /**
      * @public
      * @type {String}
      */
+
     this._id = ids.next();
     /**
      * @private
@@ -4663,16 +4863,6 @@ class FormEditor {
       properties
     });
   }
-  /**
-   * @param {string} type
-   * @param {number} priority
-   * @param {Function} handler
-   */
-
-
-  on(type, priority, handler) {
-    this.get('eventBus').on(type, priority, handler);
-  }
   /**
    * @param {string} type
    * @param {Function} handler
@@ -4745,6 +4935,14 @@ class FormEditor {
   _getModules() {
     return [ModelingModule, EditorActionsModule, KeyboardModule, SelectionModule];
   }
+  /**
+   * @internal
+   */
+
+
+  _onEvent(type, priority, handler) {
+    this.get('eventBus').on(type, priority, handler);
+  }
 
 } // helpers //////////