@limetech/lime-elements 39.13.2 → 39.14.0

package/dist/cjs/pickBy-kLjYLoam.js

@@ -0,0 +1,201 @@
+'use strict';
+
+var _baseIteratee = require('./_baseIteratee-DggA4e7a.js');
+var _assignValue = require('./_assignValue-DpsLUlF4.js');
+var isArrayLike = require('./isArrayLike-_dR1U5-Y.js');
+var isObject = require('./isObject-B6Osvvqp.js');
+var _getAllKeysIn = require('./_getAllKeysIn-BQIV8aw7.js');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.has` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHas(object, key) {
+  return object != null && hasOwnProperty.call(object, key);
+}
+
+/**
+ * Checks if `path` is a direct property of `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = { 'a': { 'b': 2 } };
+ * var other = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.has(object, 'a');
+ * // => true
+ *
+ * _.has(object, 'a.b');
+ * // => true
+ *
+ * _.has(object, ['a', 'b']);
+ * // => true
+ *
+ * _.has(other, 'a');
+ * // => false
+ */
+function has(object, path) {
+  return object != null && _baseIteratee.hasPath(object, path, baseHas);
+}
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that negates the result of the predicate `func`. The
+ * `func` predicate is invoked with the `this` binding and arguments of the
+ * created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} predicate The predicate to negate.
+ * @returns {Function} Returns the new negated function.
+ * @example
+ *
+ * function isEven(n) {
+ *   return n % 2 == 0;
+ * }
+ *
+ * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
+ * // => [1, 3, 5]
+ */
+function negate(predicate) {
+  if (typeof predicate != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  return function() {
+    var args = arguments;
+    switch (args.length) {
+      case 0: return !predicate.call(this);
+      case 1: return !predicate.call(this, args[0]);
+      case 2: return !predicate.call(this, args[0], args[1]);
+      case 3: return !predicate.call(this, args[0], args[1], args[2]);
+    }
+    return !predicate.apply(this, args);
+  };
+}
+
+/**
+ * The base implementation of `_.set`.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @param {Function} [customizer] The function to customize path creation.
+ * @returns {Object} Returns `object`.
+ */
+function baseSet(object, path, value, customizer) {
+  if (!isObject.isObject(object)) {
+    return object;
+  }
+  path = _baseIteratee.castPath(path, object);
+
+  var index = -1,
+      length = path.length,
+      lastIndex = length - 1,
+      nested = object;
+
+  while (nested != null && ++index < length) {
+    var key = _baseIteratee.toKey(path[index]),
+        newValue = value;
+
+    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+      return object;
+    }
+
+    if (index != lastIndex) {
+      var objValue = nested[key];
+      newValue = customizer ? customizer(objValue, key, nested) : undefined;
+      if (newValue === undefined) {
+        newValue = isObject.isObject(objValue)
+          ? objValue
+          : (isArrayLike.isIndex(path[index + 1]) ? [] : {});
+      }
+    }
+    _assignValue.assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+
+/**
+ * The base implementation of  `_.pickBy` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The source object.
+ * @param {string[]} paths The property paths to pick.
+ * @param {Function} predicate The function invoked per property.
+ * @returns {Object} Returns the new object.
+ */
+function basePickBy(object, paths, predicate) {
+  var index = -1,
+      length = paths.length,
+      result = {};
+
+  while (++index < length) {
+    var path = paths[index],
+        value = _baseIteratee.baseGet(object, path);
+
+    if (predicate(value, path)) {
+      baseSet(result, _baseIteratee.castPath(path, object), value);
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates an object composed of the `object` properties `predicate` returns
+ * truthy for. The predicate is invoked with two arguments: (value, key).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {Function} [predicate=_.identity] The function invoked per property.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pickBy(object, _.isNumber);
+ * // => { 'a': 1, 'c': 3 }
+ */
+function pickBy(object, predicate) {
+  if (object == null) {
+    return {};
+  }
+  var props = _baseIteratee.arrayMap(_getAllKeysIn.getAllKeysIn(object), function(prop) {
+    return [prop];
+  });
+  predicate = _baseIteratee.baseIteratee(predicate);
+  return basePickBy(object, props, function(value, path) {
+    return predicate(value, path[0]);
+  });
+}
+
+exports.basePickBy = basePickBy;
+exports.baseSet = baseSet;
+exports.has = has;
+exports.negate = negate;
+exports.pickBy = pickBy;

package/dist/cjs/{sv-jO-ewmqh.js → sv-BSR4W58y.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var moment = require('./moment-DCqC7BZP.js');
+var moment = require('./moment-CqRdiK10.js');
 
 var da$1 = {exports: {}};
 

package/dist/collection/components/form/adapters/widget-adapter.js

@@ -1,6 +1,7 @@
 import React from "react";
-import { capitalize } from "lodash-es";
+import { hasValue, isFieldInvalid, isFieldRequired, getErrorText, } from "../validation-display";
 import { getHelpComponent } from "../help";
+import { RowLayoutContext } from "../row/row-context";
 /**
  * A widget is a concept in react-jsonschema-form (rjsf).
  * It represents a HTML tag for the user to enter data, eg. input, select, etc.
@@ -23,47 +24,35 @@ export class LimeElementsWidgetAdapter extends React.Component {
         };
         this.handleBlur = this.handleBlur.bind(this);
     }
-    hasValue() {
-        const value = this.getValue();
-        if (!value) {
-            return false;
-        }
-        if (Array.isArray(value)) {
-            return value.length > 0;
-        }
-        if (value instanceof Date) {
-            return true;
-        }
-        if (typeof value === 'object') {
-            return Object.entries(value).length > 0;
-        }
-        return true;
-    }
     handleBlur() {
         this.setState({ modified: true });
     }
     getLabel() {
-        const { schema, label } = this.props.widgetProps;
+        if (this.context) {
+            return '';
+        }
+        const { schema, label, hideLabel } = this.props.widgetProps;
+        if (hideLabel) {
+            return '';
+        }
         return label || schema.title;
     }
     isInvalid() {
         const { modified } = this.state;
-        const { rawErrors } = this.props.widgetProps;
-        return (!!rawErrors && (modified || this.hasValue() || !this.isRequired()));
-    }
-    isRequired() {
-        const { required, schema } = this.props.widgetProps;
-        return required || schema.minItems > 0;
+        const { rawErrors, required, schema } = this.props.widgetProps;
+        return isFieldInvalid({
+            hasErrors: !!rawErrors,
+            modified: modified,
+            hasValue: hasValue(this.getValue()),
+            required: isFieldRequired({ required, minItems: schema.minItems }),
+        });
     }
     getHelperText() {
         const { rawErrors, schema } = this.props.widgetProps;
         if (!this.isInvalid()) {
-            return schema.description;
-        }
-        if (rawErrors) {
-            return capitalize(rawErrors[0]);
+            return this.context ? '' : schema.description;
         }
-        return schema.description;
+        return getErrorText(rawErrors || [], schema.description);
     }
     getValue() {
         const { value } = this.props;
@@ -76,7 +65,10 @@ export class LimeElementsWidgetAdapter extends React.Component {
         const disabled = this.isDisabled();
         const value = this.getValue();
         const readonly = this.isReadOnly();
-        return React.createElement(React.Fragment, {}, React.createElement(name, Object.assign(Object.assign({ value: value, label: this.getLabel(), disabled: disabled, readonly: readonly, required: this.isRequired(), invalid: this.isInvalid(), 'helper-text': this.getHelperText() }, extraProps), { onChange: this.handleChange, onBlur: this.handleBlur })), getHelpComponent(this.props.widgetProps.schema));
+        return React.createElement(React.Fragment, {}, React.createElement(name, Object.assign(Object.assign({ value: value, label: this.getLabel(), disabled: disabled, readonly: readonly, required: isFieldRequired({
+                required: this.props.widgetProps.required,
+                minItems: this.props.widgetProps.schema.minItems,
+            }), invalid: this.isInvalid(), 'helper-text': this.getHelperText() }, extraProps), { onChange: this.handleChange, onBlur: this.handleBlur })), getHelpComponent(this.props.widgetProps.schema));
     }
     isDisabled() {
         var _a, _b;
@@ -91,3 +83,4 @@ export class LimeElementsWidgetAdapter extends React.Component {
         return widgetProps.readonly;
     }
 }
+LimeElementsWidgetAdapter.contextType = RowLayoutContext;

package/dist/collection/components/form/fields/array-field.js

@@ -1,6 +1,9 @@
-import JSONArrayField from "@rjsf/core/lib/components/fields/ArrayField";
 import React from "react";
+import { getDefaultRegistry } from "@rjsf/core";
 import { resetDependentFields } from "./field-helpers";
+import { ARRAY_REORDER_EVENT } from "../templates/array-field";
+const { fields: defaultFields } = getDefaultRegistry();
+const BaseArrayField = defaultFields.ArrayField;
 /**
  * This override field exists to supplement the need to reset dependent fields
  * in SchemaField. The `resetDependentFields` function requires that the schema that
@@ -14,6 +17,10 @@ import { resetDependentFields } from "./field-helpers";
  * `resetDependentFields` on the changed list items. This is possible because the ArrayField is also given
  * the raw schema so it can properly call `resetDependentFields`
  *
+ * This field also handles drag-and-drop reordering. The ArrayFieldTemplate
+ * dispatches an `arrayReorder` DOM event when Sortable.js completes a drag.
+ * This field listens for that event and reorders the form data via onChange.
+ *
  * This form has to handle several events that can affect the list:
  *
  * 1. An on change where no list item changes
@@ -32,20 +39,46 @@ export class ArrayField extends React.Component {
     constructor(props) {
         super(props);
         this.handleChange = this.handleChange.bind(this);
+        this.handleReorder = this.handleReorder.bind(this);
+        this.setWrapper = this.setWrapper.bind(this);
+    }
+    componentWillUnmount() {
+        this.setWrapper(null);
+    }
+    setWrapper(element) {
+        if (this.wrapper) {
+            this.wrapper.removeEventListener(ARRAY_REORDER_EVENT, this.handleReorder);
+        }
+        this.wrapper = element !== null && element !== void 0 ? element : undefined;
+        if (this.wrapper) {
+            this.wrapper.addEventListener(ARRAY_REORDER_EVENT, this.handleReorder);
+        }
+    }
+    handleReorder(event) {
+        event.stopPropagation();
+        const { fromIndex, toIndex } = event.detail;
+        const { formData, fieldPathId } = this.props;
+        if (!Array.isArray(formData) || !fieldPathId) {
+            return;
+        }
+        const reordered = [...formData];
+        const [item] = reordered.splice(fromIndex, 1);
+        reordered.splice(toIndex, 0, item);
+        this.props.onChange(reordered, fieldPathId.path);
     }
-    handleChange(newData, errorSchema) {
+    handleChange(newData, path) {
         const { formData: oldData, schema } = this.props;
         const { rootSchema } = this.props.registry;
         // This case handles when the first list item is added. When there are no
         // items we get undefined instead of []
         if (!oldData) {
-            this.props.onChange(newData, errorSchema);
+            this.props.onChange(newData, path);
             return;
         }
         // This case happens when we add or remove an item from the list
         // No need to check for resetting fields unless we change data
         if (oldData.length !== newData.length) {
-            this.props.onChange(newData, errorSchema);
+            this.props.onChange(newData, path);
             return;
         }
         const nonMatchingIndices = [];
@@ -63,10 +96,10 @@ export class ArrayField extends React.Component {
             const i = nonMatchingIndices[0];
             newData[i] = resetDependentFields(oldData[i], newData[i], schema.items, rootSchema);
         }
-        this.props.onChange(newData, errorSchema);
+        this.props.onChange(newData, path);
     }
     render() {
         const arrayProps = Object.assign(Object.assign({}, this.props), { onChange: this.handleChange });
-        return React.createElement(JSONArrayField, arrayProps);
+        return React.createElement('div', { ref: this.setWrapper }, React.createElement(BaseArrayField, arrayProps));
     }
 }

package/dist/collection/components/form/fields/field-helpers.js

@@ -1,5 +1,6 @@
 import { union, isEqual, isPlainObject, negate } from "lodash-es";
-import { retrieveSchema, ADDITIONAL_PROPERTY_FLAG } from "@rjsf/core/lib/utils";
+import { retrieveSchema, ADDITIONAL_PROPERTY_FLAG } from "@rjsf/utils";
+import { rjsfValidator } from "../validator";
 /**
  * Given two objects, get a list of keys for each value that is different between
  * the two objects. Compares using deep comparison
@@ -35,9 +36,8 @@ export const resetDependentFields = (oldData, newData, schema, rootSchema) => {
         return newData;
     }
     // Get the schema generated by the current data
-    const currentSchema = retrieveSchema(schema, rootSchema, oldData);
-    // Get the new schema that is calculated for the new data
-    const newSchema = retrieveSchema(schema, rootSchema, newData);
+    const currentSchema = retrieveSchema(rjsfValidator, schema, rootSchema, oldData);
+    const newSchema = retrieveSchema(rjsfValidator, schema, rootSchema, newData);
     // Get property keys whose schema changed due to the new data.
     // These properties that have changed are the properties that are dependent on
     // data that has changed in the current onChange event

package/dist/collection/components/form/fields/object-field.js

@@ -1,12 +1,14 @@
-import JSONObjectField from "@rjsf/core/lib/components/fields/ObjectField";
 import React from "react";
+import { getDefaultRegistry } from "@rjsf/core";
 import { CodeEditor } from "../widgets/code-editor";
 import { renderDescription, renderTitle } from "../templates/common";
 import { isCustomObjectSchema } from "./field-helpers";
+const { fields: defaultFields } = getDefaultRegistry();
+const BaseObjectField = defaultFields.ObjectField;
 export class ObjectField extends React.Component {
     render() {
         if (!isCustomObjectSchema(this.props.schema)) {
-            return React.createElement(JSONObjectField, this.props);
+            return React.createElement(BaseObjectField, this.props);
         }
         return React.createElement(React.Fragment, {}, renderTitle(this.props.schema.title), renderDescription(this.props.schema.description), React.createElement(CodeEditor, this.props));
     }

package/dist/collection/components/form/fields/schema-field.js

@@ -1,10 +1,14 @@
-import JSONSchemaField from "@rjsf/core/lib/components/fields/SchemaField";
 import React from "react";
-import { isEmpty, capitalize } from "lodash-es";
+import { getDefaultRegistry } from "@rjsf/core";
+import { isEmpty } from "lodash-es";
+import { hasValue, isFieldInvalid, isFieldRequired, getErrorText, } from "../validation-display";
 import { resetDependentFields } from "./field-helpers";
 import { FieldTemplate } from "../templates";
 import { getHelpComponent } from "../help";
 import { TimePicker } from "../widgets/time-picker";
+import { RowLayoutContext } from "../row/row-context";
+const { fields: defaultFields } = getDefaultRegistry();
+const BaseSchemaField = defaultFields.SchemaField;
 /**
  * If given a value and schema, check if the value should be translated
  * from null to undefined to avoid issues with validation
@@ -48,10 +52,6 @@ const hasCustomComponent = (schema) => {
     return true;
 };
 const verifyCustomComponentIsDefined = (elementName) => {
-    const supportsCustomElements = 'customElements' in window;
-    if (!supportsCustomElements) {
-        throw new Error('Custom form elements are not supported by this browser!');
-    }
     if (!customElements.get(elementName)) {
         throw new Error(`Custom form element '${elementName}' is not defined!`);
     }
@@ -90,51 +90,23 @@ export class SchemaField extends React.Component {
         this.handleCustomComponentChange =
             this.handleCustomComponentChange.bind(this);
     }
-    hasValue() {
-        const value = this.getValue();
-        if (!value) {
-            return false;
-        }
-        if (Array.isArray(value)) {
-            return value.length > 0;
-        }
-        if (value instanceof Date) {
-            return true;
-        }
-        if (typeof value === 'object') {
-            return !isEmpty(value);
-        }
-        return true;
-    }
-    getLabel() {
-        const { schema } = this.props;
-        return schema.title;
-    }
     isInvalid() {
         const { modified } = this.state;
-        const { errorSchema } = this.props;
-        return ((modified || this.hasValue() || !this.isRequired()) &&
-            !isEmpty(errorSchema));
-    }
-    isRequired() {
-        const { required, schema } = this.props;
-        return required || schema.minItems > 0;
+        const { errorSchema, required, schema } = this.props;
+        return isFieldInvalid({
+            hasErrors: !isEmpty(errorSchema),
+            modified: modified,
+            hasValue: hasValue(this.props.formData),
+            required: isFieldRequired({ required, minItems: schema.minItems }),
+        });
     }
     getHelperText() {
         var _a, _b, _c;
         const { errorSchema, schema } = this.props;
-        if (!this.isInvalid()) {
-            const helperText = (_c = (_b = (_a = schema.lime) === null || _a === void 0 ? void 0 : _a.component) === null || _b === void 0 ? void 0 : _b.props) === null || _c === void 0 ? void 0 : _c.helperText;
-            return helperText || schema.description;
-        }
-        if (!isEmpty(errorSchema) && '__errors' in errorSchema) {
-            return capitalize(errorSchema.__errors[0]);
-        }
-        return schema.description;
-    }
-    getValue() {
-        const { formData } = this.props;
-        return formData;
+        const hasErrors = !isEmpty(errorSchema) && '__errors' in errorSchema;
+        const errors = this.isInvalid() && hasErrors ? errorSchema.__errors : [];
+        const fallbackText = (_c = (_b = (_a = schema.lime) === null || _a === void 0 ? void 0 : _a.component) === null || _b === void 0 ? void 0 : _b.props) === null || _c === void 0 ? void 0 : _c.helperText;
+        return getErrorText(errors, schema.description, fallbackText);
     }
     handleCustomComponentChange(event) {
         const { schema } = this.props;
@@ -143,35 +115,41 @@ export class SchemaField extends React.Component {
         if (shouldChangeToUndefined(value, schema)) {
             value = undefined;
         }
-        this.handleChange(value);
+        this.handleChange(value, this.props.fieldPathId.path);
     }
-    handleChange(data) {
+    handleChange(data, path) {
         const { formData, schema } = this.props;
         const { rootSchema } = this.props.registry;
         this.setState({ modified: true });
         const newData = resetDependentFields(formData, data, schema, rootSchema);
-        this.props.onChange(newData);
+        this.props.onChange(newData, path);
     }
     buildCustomComponentProps() {
-        const { disabled, readonly, name, registry, schema, errorSchema, idSchema, } = this.props;
+        const { disabled, readonly, name, registry, schema: rawSchema, errorSchema, fieldPathId, } = this.props;
+        const schema = rawSchema;
         const factoryProps = getFactoryProps(registry.formContext, schema);
-        return Object.assign(Object.assign({}, factoryProps), { value: this.getValue(), required: this.isRequired(), readonly: readonly || schema.readOnly, disabled: disabled, invalid: this.isInvalid(), label: this.getLabel(), helperText: this.getHelperText(), ref: (element) => {
+        return Object.assign(Object.assign({}, factoryProps), { value: this.props.formData, required: isFieldRequired({
+                required: this.props.required,
+                minItems: schema.minItems,
+            }), readonly: readonly || schema.readOnly, disabled: disabled, invalid: this.isInvalid(), label: this.context ? '' : schema.title, helperText: this.context && !this.isInvalid() ? '' : this.getHelperText(), ref: (element) => {
+                var _a;
                 element.formInfo = {
                     schema: schema,
                     rootSchema: registry.formContext.schema,
                     errorSchema: errorSchema,
                     rootValue: registry.formContext.rootValue,
                     name: name,
-                    schemaPath: this.getSchemaPath(idSchema === null || idSchema === void 0 ? void 0 : idSchema.$id),
+                    schemaPath: (_a = fieldPathId === null || fieldPathId === void 0 ? void 0 : fieldPathId.path) === null || _a === void 0 ? void 0 : _a.map(String),
                 };
                 return () => { };
             } });
     }
     renderCustomComponent(props) {
-        const { name, props: userDefinedComponentProps } = getCustomComponent(props.schema);
+        const schema = props.schema;
+        const { name, props: userDefinedComponentProps } = getCustomComponent(schema);
         verifyCustomComponentIsDefined(name);
         const component = React.createElement(name, Object.assign(Object.assign(Object.assign({}, userDefinedComponentProps), this.buildCustomComponentProps()), { onChange: this.handleCustomComponentChange }));
-        return React.createElement(FieldTemplate, Object.assign(Object.assign({}, this.props), { classNames: 'form-group field field-custom' }), component, getHelpComponent(props.schema));
+        return React.createElement(FieldTemplate, Object.assign(Object.assign({}, this.props), { classNames: 'rjsf-field rjsf-field-custom' }), component, getHelpComponent(schema));
     }
     render() {
         var _a;
@@ -185,22 +163,7 @@ export class SchemaField extends React.Component {
         if (this.props.schema.format === 'time') {
             fieldProps.uiSchema = Object.assign({ 'ui:widget': TimePicker }, fieldProps.uiSchema);
         }
-        return React.createElement(JSONSchemaField, fieldProps);
-    }
-    /**
-     * Gets the path to the current property within the schema
-     *
-     * @param schemaId - the id of the schema
-     * @returns an array with the schema path for the current property
-     * @example
-     * const schemaId = 'root_sections_0_controls_0_name';
-     * const schemaPath = getSchemaPath(schemaId);
-     * // ➡ ['sections', '0', 'controls', '0', 'name']
-     */
-    getSchemaPath(schemaId) {
-        if (schemaId === undefined) {
-            return undefined;
-        }
-        return schemaId.replace('root_', '').split('_');
+        return React.createElement(BaseSchemaField, fieldProps);
     }
 }
+SchemaField.contextType = RowLayoutContext;