@bpmn-io/form-js-viewer 0.7.1 → 0.8.0-alpha.1

package/dist/index.cjs

@@ -8,14 +8,17 @@ var snarkdown = require('@bpmn-io/snarkdown');
 var jsxRuntime = require('preact/jsx-runtime');
 var hooks = require('preact/hooks');
 var preact = require('preact');
+var React = require('preact/compat');
+var classNames = require('classnames');
 var Markup = require('preact-markup');
-var compat = require('preact/compat');
 var didi = require('didi');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var Ids__default = /*#__PURE__*/_interopDefaultLegacy(Ids);
 var snarkdown__default = /*#__PURE__*/_interopDefaultLegacy(snarkdown);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);
 var Markup__default = /*#__PURE__*/_interopDefaultLegacy(Markup);
 
 var FN_REF = '__fn';
@@ -598,45 +601,8 @@ class FormFieldRegistry {
 FormFieldRegistry.$inject = ['eventBus'];
 
 function createInjector(bootstrapModules) {
-  const modules = [],
-        components = [];
-
-  function hasModule(module) {
-    return modules.includes(module);
-  }
-
-  function addModule(module) {
-    modules.push(module);
-  }
-
-  function visit(module) {
-    if (hasModule(module)) {
-      return;
-    }
-
-    (module.__depends__ || []).forEach(visit);
-
-    if (hasModule(module)) {
-      return;
-    }
-
-    addModule(module);
-    (module.__init__ || []).forEach(function (component) {
-      components.push(component);
-    });
-  }
-
-  bootstrapModules.forEach(visit);
-  const injector = new didi.Injector(modules);
-  components.forEach(function (component) {
-    try {
-      injector[typeof component === 'string' ? 'get' : 'invoke'](component);
-    } catch (err) {
-      console.error('Failed to instantiate component');
-      console.error(err.stack);
-      throw err;
-    }
-  });
+  const injector = new didi.Injector(bootstrapModules);
+  injector.init();
   return injector;
 }
 
@@ -699,6 +665,41 @@ function generateIdForType(type) {
 function clone(data, replacer) {
   return JSON.parse(JSON.stringify(data, replacer));
 }
+/**
+ * Parse the schema for input variables a form might make use of
+ *
+ * @param {any} schema
+ *
+ * @return {string[]}
+ */
+
+function getSchemaVariables(schema) {
+  if (!schema.components) {
+    return [];
+  }
+
+  return schema.components.reduce((variables, component) => {
+    const {
+      key,
+      valuesKey,
+      type
+    } = component;
+
+    if (['text', 'button'].includes(type)) {
+      return variables;
+    }
+
+    if (key) {
+      variables = [...variables, key];
+    }
+
+    if (valuesKey && !variables.includes(valuesKey)) {
+      variables = [...variables, valuesKey];
+    }
+
+    return variables;
+  }, []);
+}
 
 class Importer {
   /**
@@ -723,7 +724,7 @@ class Importer {
 
 
   importSchema(schema, data = {}) {
-    // TODO: Add warnings
+    // TODO: Add warnings - https://github.com/bpmn-io/form-js/issues/289
     const warnings = [];
 
     try {
@@ -817,19 +818,39 @@ class Importer {
       const {
         defaultValue,
         _path,
-        type
-      } = formField;
-
-      if (!_path) {
-        return importedData;
-      } // (1) try to get value from data
-      // (2) try to get default value from form field
-      // (3) get empty value from form field
-
+        type,
+        valuesKey
+      } = formField; // get values defined via valuesKey
+
+      if (valuesKey) {
+        importedData = { ...importedData,
+          [valuesKey]: minDash.get(data, [valuesKey])
+        };
+      } // try to get value from data
+      // if unavailable - try to get default value from form field
+      // if unavailable - get empty value from form field
+
+
+      if (_path) {
+        const fieldImplementation = this._formFields.get(type);
+
+        let valueData = minDash.get(data, _path);
+
+        if (!minDash.isUndefined(valueData) && fieldImplementation.sanitizeValue) {
+          valueData = fieldImplementation.sanitizeValue({
+            formField,
+            data,
+            value: valueData
+          });
+        }
+
+        const initialFieldValue = !minDash.isUndefined(valueData) ? valueData : !minDash.isUndefined(defaultValue) ? defaultValue : fieldImplementation.emptyValue;
+        importedData = { ...importedData,
+          [_path[0]]: initialFieldValue
+        };
+      }
 
-      return { ...importedData,
-        [_path[0]]: minDash.get(data, _path, minDash.isUndefined(defaultValue) ? this._formFields.get(type).emptyValue : defaultValue)
-      };
+      return importedData;
     }, {});
   }
 
@@ -989,8 +1010,48 @@ function safeMarkdown(markdown) {
   const html = markdownToHTML(markdown);
   return sanitizeHTML(html);
 }
+function sanitizeSingleSelectValue(options) {
+  const {
+    formField,
+    data,
+    value
+  } = options;
+  const {
+    valuesKey,
+    values
+  } = formField;
+
+  try {
+    const validValues = (valuesKey ? minDash.get(data, [valuesKey]) : values).map(v => v.value) || [];
+    return validValues.includes(value) ? value : null;
+  } catch (error) {
+    // use default value in case of formatting error
+    // TODO(@Skaiir): log a warning when this happens - https://github.com/bpmn-io/form-js/issues/289
+    return null;
+  }
+}
+function sanitizeMultiSelectValue(options) {
+  const {
+    formField,
+    data,
+    value
+  } = options;
+  const {
+    valuesKey,
+    values
+  } = formField;
+
+  try {
+    const validValues = (valuesKey ? minDash.get(data, [valuesKey]) : values).map(v => v.value) || [];
+    return value.filter(v => validValues.includes(v));
+  } catch (error) {
+    // use default value in case of formatting error
+    // TODO(@Skaiir): log a warning when this happens - https://github.com/bpmn-io/form-js/issues/289
+    return [];
+  }
+}
 
-const type$6 = 'button';
+const type$8 = 'button';
 function Button(props) {
   const {
     disabled,
@@ -1000,7 +1061,7 @@ function Button(props) {
     action = 'submit'
   } = field;
   return jsxRuntime.jsx("div", {
-    class: formFieldClasses(type$6),
+    class: formFieldClasses(type$8),
     children: jsxRuntime.jsx("button", {
       class: "fjs-button",
       type: action,
@@ -1017,7 +1078,7 @@ Button.create = function (options = {}) {
   };
 };
 
-Button.type = type$6;
+Button.type = type$8;
 Button.label = 'Button';
 Button.keyed = true;
 
@@ -1099,7 +1160,7 @@ function Label(props) {
   });
 }
 
-const type$5 = 'checkbox';
+const type$7 = 'checkbox';
 function Checkbox(props) {
   const {
     disabled,
@@ -1126,7 +1187,7 @@ function Checkbox(props) {
     formId
   } = hooks.useContext(FormContext);
   return jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$5, errors),
+    class: formFieldClasses(type$7, errors),
     children: [jsxRuntime.jsx(Label, {
       id: prefixId(id, formId),
       label: label,
@@ -1152,11 +1213,15 @@ Checkbox.create = function (options = {}) {
   };
 };
 
-Checkbox.type = type$5;
+Checkbox.type = type$7;
 Checkbox.label = 'Checkbox';
 Checkbox.keyed = true;
 Checkbox.emptyValue = false;
 
+Checkbox.sanitizeValue = ({
+  value
+}) => value === true;
+
 function useService (type, strict) {
   const {
     getService
@@ -1164,6 +1229,153 @@ function useService (type, strict) {
   return getService(type, strict);
 }
 
+/**
+ * @enum { String }
+ */
+
+const LOAD_STATES = {
+  LOADING: 'loading',
+  LOADED: 'loaded',
+  ERROR: 'error'
+};
+/**
+ * @typedef {Object} ValuesGetter
+ * @property {Object[]} values - The values data
+ * @property {(LOAD_STATES)} state - The values data's loading state, to use for conditional rendering
+ */
+
+/**
+ * A hook to load values for single and multiselect components.
+ *
+ * @param {Object} field - The form field to handle values for
+ * @return {ValuesGetter} valuesGetter - A values getter object providing loading state and values
+ */
+
+function useValuesAsync (field) {
+  const {
+    valuesKey,
+    values: staticValues
+  } = field;
+  const [valuesGetter, setValuesGetter] = hooks.useState({
+    values: [],
+    error: undefined,
+    state: LOAD_STATES.LOADING
+  });
+
+  const initialData = useService('form')._getState().initialData;
+
+  hooks.useEffect(() => {
+    let values = [];
+
+    if (valuesKey !== undefined) {
+      const keyedValues = (initialData || {})[valuesKey];
+
+      if (keyedValues && Array.isArray(keyedValues)) {
+        values = keyedValues;
+      }
+    } else if (staticValues !== undefined) {
+      values = Array.isArray(staticValues) ? staticValues : [];
+    } else {
+      setValuesGetter(getErrorState('No values source defined in the form definition'));
+      return;
+    }
+
+    setValuesGetter(buildLoadedState(values));
+  }, [valuesKey, staticValues, initialData]);
+  return valuesGetter;
+}
+
+const getErrorState = error => ({
+  values: [],
+  error,
+  state: LOAD_STATES.ERROR
+});
+
+const buildLoadedState = values => ({
+  values,
+  error: undefined,
+  state: LOAD_STATES.LOADED
+});
+
+const type$6 = 'checklist';
+function Checklist(props) {
+  const {
+    disabled,
+    errors = [],
+    field,
+    value = []
+  } = props;
+  const {
+    description,
+    id,
+    label
+  } = field;
+
+  const toggleCheckbox = v => {
+    let newValue = [...value];
+
+    if (!newValue.includes(v)) {
+      newValue.push(v);
+    } else {
+      newValue = newValue.filter(x => x != v);
+    }
+
+    props.onChange({
+      field,
+      value: newValue
+    });
+  };
+
+  const {
+    state: loadState,
+    values: options
+  } = useValuesAsync(field);
+  const {
+    formId
+  } = hooks.useContext(FormContext);
+  return jsxRuntime.jsxs("div", {
+    class: formFieldClasses(type$6, errors),
+    children: [jsxRuntime.jsx(Label, {
+      label: label
+    }), loadState == LOAD_STATES.LOADED && options.map((v, index) => {
+      return jsxRuntime.jsx(Label, {
+        id: prefixId(`${id}-${index}`, formId),
+        label: v.label,
+        required: false,
+        children: jsxRuntime.jsx("input", {
+          checked: value.includes(v.value),
+          class: "fjs-input",
+          disabled: disabled,
+          id: prefixId(`${id}-${index}`, formId),
+          type: "checkbox",
+          onClick: () => toggleCheckbox(v.value)
+        })
+      }, `${id}-${index}`);
+    }), jsxRuntime.jsx(Description, {
+      description: description
+    }), jsxRuntime.jsx(Errors, {
+      errors: errors
+    })]
+  });
+}
+
+Checklist.create = function (options = {}) {
+  if (options.valuesKey) return options;
+  return {
+    values: [{
+      label: 'Value',
+      value: 'value'
+    }],
+    ...options
+  };
+};
+
+Checklist.type = type$6;
+Checklist.label = 'Checklist';
+Checklist.keyed = true;
+Checklist.emptyValue = [];
+Checklist.sanitizeValue = sanitizeMultiSelectValue;
+
 const noop$1 = () => false;
 
 function FormField(props) {
@@ -1327,7 +1539,7 @@ function PoweredBy(props) {
   }
 
   return jsxRuntime.jsxs(preact.Fragment, {
-    children: [compat.createPortal(jsxRuntime.jsx(Lightbox, {
+    children: [React.createPortal(jsxRuntime.jsx(Lightbox, {
       open: open,
       onBackdropClick: toggleOpen(false)
     }), document.body), jsxRuntime.jsx(Link, {
@@ -1372,7 +1584,7 @@ function FormComponent(props) {
   });
 }
 
-const type$4 = 'number';
+const type$5 = 'number';
 function Number(props) {
   const {
     disabled,
@@ -1393,10 +1605,11 @@ function Number(props) {
   const onChange = ({
     target
   }) => {
-    const parsedValue = parseInt(target.value, 10);
     props.onChange({
       field,
-      value: isNaN(parsedValue) ? null : parsedValue
+      value: Number.sanitizeValue({
+        value: target.value
+      })
     });
   };
 
@@ -1404,7 +1617,7 @@ function Number(props) {
     formId
   } = hooks.useContext(FormContext);
   return jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$4, errors),
+    class: formFieldClasses(type$5, errors),
     children: [jsxRuntime.jsx(Label, {
       id: prefixId(id, formId),
       label: label,
@@ -1429,12 +1642,19 @@ Number.create = function (options = {}) {
   };
 };
 
-Number.type = type$4;
+Number.sanitizeValue = ({
+  value
+}) => {
+  const parsedValue = parseInt(value, 10);
+  return isNaN(parsedValue) ? null : parsedValue;
+};
+
+Number.type = type$5;
 Number.keyed = true;
 Number.label = 'Number';
 Number.emptyValue = null;
 
-const type$3 = 'radio';
+const type$4 = 'radio';
 function Radio(props) {
   const {
     disabled,
@@ -1446,8 +1666,7 @@ function Radio(props) {
     description,
     id,
     label,
-    validate = {},
-    values
+    validate = {}
   } = field;
   const {
     required
@@ -1460,26 +1679,30 @@ function Radio(props) {
     });
   };
 
+  const {
+    state: loadState,
+    values: options
+  } = useValuesAsync(field);
   const {
     formId
   } = hooks.useContext(FormContext);
   return jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$3, errors),
+    class: formFieldClasses(type$4, errors),
     children: [jsxRuntime.jsx(Label, {
       label: label,
       required: required
-    }), values.map((v, index) => {
+    }), loadState == LOAD_STATES.LOADED && options.map((option, index) => {
       return jsxRuntime.jsx(Label, {
         id: prefixId(`${id}-${index}`, formId),
-        label: v.label,
+        label: option.label,
         required: false,
         children: jsxRuntime.jsx("input", {
-          checked: v.value === value,
+          checked: option.value === value,
           class: "fjs-input",
           disabled: disabled,
           id: prefixId(`${id}-${index}`, formId),
           type: "radio",
-          onClick: () => onChange(v.value)
+          onClick: () => onChange(option.value)
         })
       }, `${id}-${index}`);
     }), jsxRuntime.jsx(Description, {
@@ -1491,6 +1714,7 @@ function Radio(props) {
 }
 
 Radio.create = function (options = {}) {
+  if (options.valuesKey) return options;
   return {
     values: [{
       label: 'Value',
@@ -1500,12 +1724,13 @@ Radio.create = function (options = {}) {
   };
 };
 
-Radio.type = type$3;
+Radio.type = type$4;
 Radio.label = 'Radio';
 Radio.keyed = true;
 Radio.emptyValue = null;
+Radio.sanitizeValue = sanitizeSingleSelectValue;
 
-const type$2 = 'select';
+const type$3 = 'select';
 function Select(props) {
   const {
     disabled,
@@ -1517,8 +1742,7 @@ function Select(props) {
     description,
     id,
     label,
-    validate = {},
-    values
+    validate = {}
   } = field;
   const {
     required
@@ -1533,11 +1757,15 @@ function Select(props) {
     });
   };
 
+  const {
+    state: loadState,
+    values: options
+  } = useValuesAsync(field);
   const {
     formId
   } = hooks.useContext(FormContext);
   return jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$2, errors),
+    class: formFieldClasses(type$3, errors),
     children: [jsxRuntime.jsx(Label, {
       id: prefixId(id, formId),
       label: label,
@@ -1550,10 +1778,10 @@ function Select(props) {
       value: value || '',
       children: [jsxRuntime.jsx("option", {
         value: ""
-      }), values.map((v, index) => {
+      }), loadState == LOAD_STATES.LOADED && options.map((option, index) => {
         return jsxRuntime.jsx("option", {
-          value: v.value,
-          children: v.label
+          value: option.value,
+          children: option.label
         }, `${id}-${index}`);
       })]
     }), jsxRuntime.jsx(Description, {
@@ -1565,6 +1793,7 @@ function Select(props) {
 }
 
 Select.create = function (options = {}) {
+  if (options.valuesKey) return options;
   return {
     values: [{
       label: 'Value',
@@ -1574,10 +1803,314 @@ Select.create = function (options = {}) {
   };
 };
 
-Select.type = type$2;
+Select.type = type$3;
 Select.label = 'Select';
 Select.keyed = true;
 Select.emptyValue = null;
+Select.sanitizeValue = sanitizeSingleSelectValue;
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+var CloseIcon = (({
+  styles = {},
+  ...props
+}) => /*#__PURE__*/React__default['default'].createElement("svg", _extends({
+  width: "16",
+  height: "16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+}, props), /*#__PURE__*/React__default['default'].createElement("path", {
+  fillRule: "evenodd",
+  clipRule: "evenodd",
+  d: "M12 4.7l-.7-.7L8 7.3 4.7 4l-.7.7L7.3 8 4 11.3l.7.7L8 8.7l3.3 3.3.7-.7L8.7 8 12 4.7z",
+  fill: "#000"
+})));
+
+function useKeyDownAction(targetKey, action, listenerElement = window) {
+  function downHandler({
+    key
+  }) {
+    if (key === targetKey) {
+      action();
+    }
+  }
+
+  hooks.useEffect(() => {
+    listenerElement.addEventListener('keydown', downHandler);
+    return () => {
+      listenerElement.removeEventListener('keydown', downHandler);
+    };
+  });
+}
+
+const DEFAULT_LABEL_GETTER = value => value;
+
+const NOOP = () => {};
+
+function DropdownList(props) {
+  const {
+    keyEventsListener = window,
+    values = [],
+    getLabel = DEFAULT_LABEL_GETTER,
+    onValueSelected = NOOP,
+    height = 235,
+    emptyListMessage = 'No results'
+  } = props;
+  const [mouseControl, setMouseControl] = hooks.useState(true);
+  const [focusedValueIndex, setFocusedValueIndex] = hooks.useState(0);
+  const dropdownContainer = hooks.useRef();
+  const mouseScreenPos = hooks.useRef();
+  const focusedItem = hooks.useMemo(() => values.length ? values[focusedValueIndex] : null, [focusedValueIndex, values]);
+  const changeFocusedValueIndex = hooks.useCallback(delta => {
+    setFocusedValueIndex(x => Math.min(Math.max(0, x + delta), values.length - 1));
+  }, [values.length]);
+  hooks.useEffect(() => {
+    if (focusedValueIndex === 0) return;
+
+    if (!focusedValueIndex || !values.length) {
+      setFocusedValueIndex(0);
+    } else if (focusedValueIndex >= values.length) {
+      setFocusedValueIndex(values.length - 1);
+    }
+  }, [focusedValueIndex, values.length]);
+  useKeyDownAction('ArrowUp', () => {
+    if (values.length) {
+      changeFocusedValueIndex(-1);
+      setMouseControl(false);
+    }
+  }, keyEventsListener);
+  useKeyDownAction('ArrowDown', () => {
+    if (values.length) {
+      changeFocusedValueIndex(1);
+      setMouseControl(false);
+    }
+  }, keyEventsListener);
+  useKeyDownAction('Enter', () => {
+    if (focusedItem) {
+      onValueSelected(focusedItem);
+    }
+  }, keyEventsListener);
+  hooks.useEffect(() => {
+    const individualEntries = dropdownContainer.current.children;
+
+    if (individualEntries.length && !mouseControl) {
+      individualEntries[focusedValueIndex].scrollIntoView({
+        block: 'nearest',
+        inline: 'nearest'
+      });
+    }
+  }, [focusedValueIndex, mouseControl]);
+
+  const mouseMove = (e, i) => {
+    const userMoved = !mouseScreenPos.current || mouseScreenPos.current.x !== e.screenX && mouseScreenPos.current.y !== e.screenY;
+
+    if (userMoved) {
+      mouseScreenPos.current = {
+        x: e.screenX,
+        y: e.screenY
+      };
+
+      if (!mouseControl) {
+        setMouseControl(true);
+        setFocusedValueIndex(i);
+      }
+    }
+  };
+
+  return jsxRuntime.jsxs("div", {
+    ref: dropdownContainer,
+    tabIndex: -1,
+    class: "fjs-dropdownlist",
+    style: {
+      maxHeight: height
+    },
+    children: [!!values.length && values.map((v, i) => {
+      return jsxRuntime.jsx("div", {
+        class: 'fjs-dropdownlist-item' + (focusedValueIndex === i ? ' focused' : ''),
+        onMouseMove: e => mouseMove(e, i),
+        onMouseEnter: mouseControl ? () => setFocusedValueIndex(i) : undefined,
+        onMouseDown: e => {
+          e.preventDefault();
+          onValueSelected(v);
+        },
+        children: getLabel(v)
+      });
+    }), !values.length && jsxRuntime.jsx("div", {
+      class: "fjs-dropdownlist-empty",
+      children: emptyListMessage
+    })]
+  });
+}
+
+const type$2 = 'taglist';
+function Taglist(props) {
+  const {
+    disabled,
+    errors = [],
+    field,
+    value: values = []
+  } = props;
+  const {
+    description,
+    id,
+    label
+  } = field;
+  const {
+    formId
+  } = hooks.useContext(FormContext);
+  const [filter, setFilter] = hooks.useState('');
+  const [selectedValues, setSelectedValues] = hooks.useState([]);
+  const [filteredValues, setFilteredValues] = hooks.useState([]);
+  const [isDropdownExpanded, setIsDropdownExpanded] = hooks.useState(false);
+  const [hasValuesLeft, setHasValuesLeft] = hooks.useState(true);
+  const [isEscapeClosed, setIsEscapeClose] = hooks.useState(false);
+  const searchbarRef = hooks.useRef();
+  const {
+    state: loadState,
+    values: options
+  } = useValuesAsync(field); // Usage of stringify is necessary here because we want this effect to only trigger when there is a value change to the array
+
+  hooks.useEffect(() => {
+    if (loadState === LOAD_STATES.LOADED) {
+      const selectedValues = values.map(v => options.find(o => o.value === v)).filter(v => v !== undefined);
+      setSelectedValues(selectedValues);
+    } else {
+      setSelectedValues([]);
+    }
+  }, [JSON.stringify(values), options, loadState]);
+  hooks.useEffect(() => {
+    if (loadState === LOAD_STATES.LOADED) {
+      setFilteredValues(options.filter(o => o.label && o.value && o.label.toLowerCase().includes(filter.toLowerCase()) && !values.includes(o.value)));
+    } else {
+      setFilteredValues([]);
+    }
+  }, [filter, JSON.stringify(values), options]);
+  hooks.useEffect(() => {
+    setHasValuesLeft(selectedValues.length < options.length);
+  }, [selectedValues.length, options.length]);
+
+  const onFilterChange = ({
+    target
+  }) => {
+    setIsEscapeClose(false);
+    setFilter(target.value);
+  };
+
+  const selectValue = option => {
+    setFilter('');
+    props.onChange({
+      value: [...values, option.value],
+      field
+    });
+  };
+
+  const deselectValue = option => {
+    props.onChange({
+      value: values.filter(v => v != option.value),
+      field
+    });
+  };
+
+  const onInputKeyDown = e => {
+    switch (e.key) {
+      case 'ArrowUp':
+      case 'ArrowDown':
+        // We do not want the cursor to seek in the search field when we press up and down
+        e.preventDefault();
+        break;
+
+      case 'Backspace':
+        if (!filter && selectedValues.length) {
+          deselectValue(selectedValues[selectedValues.length - 1]);
+        }
+
+        break;
+
+      case 'Escape':
+        setIsEscapeClose(true);
+        break;
+
+      case 'Enter':
+        if (isEscapeClosed) {
+          setIsEscapeClose(false);
+        }
+
+        break;
+    }
+  };
+
+  return jsxRuntime.jsxs("div", {
+    class: formFieldClasses(type$2, errors),
+    children: [jsxRuntime.jsx(Label, {
+      label: label,
+      id: prefixId(id, formId)
+    }), jsxRuntime.jsxs("div", {
+      class: classNames__default['default']('fjs-taglist', {
+        'disabled': disabled
+      }),
+      children: [!disabled && loadState === LOAD_STATES.LOADED && selectedValues.map(sv => {
+        return jsxRuntime.jsxs("div", {
+          class: "fjs-taglist-tag",
+          onMouseDown: e => e.preventDefault(),
+          children: [jsxRuntime.jsx("span", {
+            class: "fjs-taglist-tag-label",
+            children: sv.label
+          }), jsxRuntime.jsx("span", {
+            class: "fjs-taglist-tag-remove",
+            onMouseDown: () => deselectValue(sv),
+            children: jsxRuntime.jsx(CloseIcon, {})
+          })]
+        });
+      }), jsxRuntime.jsx("input", {
+        disabled: disabled,
+        class: "fjs-taglist-input",
+        ref: searchbarRef,
+        id: prefixId(`${id}-search`, formId),
+        onChange: onFilterChange,
+        type: "text",
+        value: filter,
+        placeholder: 'Search',
+        autoComplete: "off",
+        onKeyDown: e => onInputKeyDown(e),
+        onMouseDown: () => setIsEscapeClose(false),
+        onFocus: () => setIsDropdownExpanded(true),
+        onBlur: () => {
+          setIsDropdownExpanded(false);
+          setFilter('');
+        }
+      })]
+    }), jsxRuntime.jsx("div", {
+      class: "fjs-taglist-anchor",
+      children: !disabled && loadState === LOAD_STATES.LOADED && isDropdownExpanded && !isEscapeClosed && jsxRuntime.jsx(DropdownList, {
+        values: filteredValues,
+        getLabel: v => v.label,
+        onValueSelected: v => selectValue(v),
+        emptyListMessage: hasValuesLeft ? 'No results' : 'All values selected',
+        listenerElement: searchbarRef.current
+      })
+    }), jsxRuntime.jsx(Description, {
+      description: description
+    }), jsxRuntime.jsx(Errors, {
+      errors: errors
+    })]
+  });
+}
+
+Taglist.create = function (options = {}) {
+  if (options.valuesKey) return options;
+  return {
+    values: [{
+      label: 'Value',
+      value: 'value'
+    }],
+    ...options
+  };
+};
+
+Taglist.type = type$2;
+Taglist.label = 'Taglist';
+Taglist.keyed = true;
+Taglist.emptyValue = [];
+Taglist.sanitizeValue = sanitizeMultiSelectValue;
 
 const type$1 = 'text';
 function Text(props) {
@@ -1667,7 +2200,11 @@ Textfield.label = 'Text Field';
 Textfield.keyed = true;
 Textfield.emptyValue = '';
 
-const formFields = [Button, Checkbox, Default, Number, Radio, Select, Text, Textfield];
+Textfield.sanitizeValue = ({
+  value
+}) => minDash.isArray(value) || minDash.isObject(value) ? null : String(value);
+
+const formFields = [Button, Checkbox, Checklist, Default, Number, Radio, Select, Taglist, Text, Textfield];
 
 class FormFields {
   constructor() {
@@ -2154,7 +2691,7 @@ class Form {
 
 }
 
-const schemaVersion = 4;
+const schemaVersion = 5;
 /**
  * @typedef { import('./types').CreateFormOptions } CreateFormOptions
  */
@@ -2181,6 +2718,7 @@ function createForm(options) {
 
 exports.Button = Button;
 exports.Checkbox = Checkbox;
+exports.Checklist = Checklist;
 exports.Default = Default;
 exports.Form = Form;
 exports.FormComponent = FormComponent;
@@ -2191,6 +2729,7 @@ exports.FormRenderContext = FormRenderContext;
 exports.Number = Number;
 exports.Radio = Radio;
 exports.Select = Select;
+exports.Taglist = Taglist;
 exports.Text = Text;
 exports.Textfield = Textfield;
 exports.clone = clone;
@@ -2201,6 +2740,7 @@ exports.findErrors = findErrors;
 exports.formFields = formFields;
 exports.generateIdForType = generateIdForType;
 exports.generateIndexForType = generateIndexForType;
+exports.getSchemaVariables = getSchemaVariables;
 exports.isRequired = isRequired;
 exports.pathParse = pathParse;
 exports.pathStringify = pathStringify;