iglooform 2.3.3 → 2.3.7

package/es/free-form/messages.d.ts

@@ -0,0 +1,48 @@
+declare const messages: {
+    default: string;
+    required: string;
+    enum: string;
+    whitespace: string;
+    date: {
+        format: string;
+        parse: string;
+        invalid: string;
+    };
+    types: {
+        string: string;
+        method: string;
+        array: string;
+        object: string;
+        number: string;
+        date: string;
+        boolean: string;
+        integer: string;
+        float: string;
+        regexp: string;
+        email: string;
+        url: string;
+        hex: string;
+    };
+    string: {
+        len: string;
+        min: string;
+        max: string;
+        range: string;
+    };
+    number: {
+        len: string;
+        min: string;
+        max: string;
+        range: string;
+    };
+    array: {
+        len: string;
+        min: string;
+        max: string;
+        range: string;
+    };
+    pattern: {
+        mismatch: string;
+    };
+};
+export default messages;

package/es/free-form/messages.js

@@ -0,0 +1,49 @@
+var typeTemplate = '${label} is not a valid ${type}';
+var messages = {
+  default: 'Validation error on field ${label}',
+  required: '${label} is required',
+  enum: '${label} must be one of [${enum}]',
+  whitespace: '${label} cannot be empty',
+  date: {
+    format: '${label} is invalid for format date',
+    parse: '${label} could not be parsed as date',
+    invalid: '${label} is invalid date'
+  },
+  types: {
+    string: typeTemplate,
+    method: typeTemplate,
+    array: typeTemplate,
+    object: typeTemplate,
+    number: typeTemplate,
+    date: typeTemplate,
+    boolean: typeTemplate,
+    integer: typeTemplate,
+    float: typeTemplate,
+    regexp: typeTemplate,
+    email: typeTemplate,
+    url: typeTemplate,
+    hex: typeTemplate
+  },
+  string: {
+    len: '${label} must be exactly ${len} characters',
+    min: '${label} must be at least ${min} characters',
+    max: '${label} cannot be longer than ${max} characters',
+    range: '${label} must be between ${min} and ${max} characters'
+  },
+  number: {
+    len: '${label} must equal ${len}',
+    min: '${label} cannot be less than ${min}',
+    max: '${label} cannot be greater than ${max}',
+    range: '${label} must be between ${min} and ${max}'
+  },
+  array: {
+    len: '${label} must be exactly ${len} in length',
+    min: '${label} cannot be less than ${min} in length',
+    max: '${label} cannot be greater than ${max} in length',
+    range: '${label} must be between ${min} and ${max} in length'
+  },
+  pattern: {
+    mismatch: '${label} does not match pattern ${pattern}'
+  }
+};
+export default messages;

package/es/free-form/page/index.d.ts

@@ -0,0 +1,11 @@
+import { FC } from 'react';
+import { FormItemConfig, FormItemName } from '../../types';
+import './style/index.less';
+export interface PageProps extends FormItemConfig {
+    parentName?: FormItemName;
+    showFooter?: boolean;
+    buttonPlacement?: 'right' | 'left';
+    description?: string;
+}
+declare const Page: FC<PageProps>;
+export default Page;

package/es/free-form/page/index.js

@@ -0,0 +1,144 @@
+import "antd/es/form/style";
+import _Form from "antd/es/form";
+import "antd/es/row/style";
+import _Row from "antd/es/row";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useEffect, cloneElement, isValidElement, useMemo, useReducer } from 'react';
+import Button from '../../button';
+import { calcNamePath } from '../utils';
+import FormContext from '../context';
+import { LocaleContext } from '../../locale';
+import Typography from '../../typography';
+import './style/index.less';
+
+var Page = function Page(_ref) {
+  var parentName = _ref.parentName,
+      name = _ref.name,
+      getButtonDisabledState = _ref.getButtonDisabledState,
+      shouldRender = _ref.shouldRender,
+      _ref$buttonPlacement = _ref.buttonPlacement,
+      buttonPlacement = _ref$buttonPlacement === void 0 ? 'right' : _ref$buttonPlacement,
+      _ref$showFooter = _ref.showFooter,
+      showFooter = _ref$showFooter === void 0 ? true : _ref$showFooter,
+      children = _ref.children,
+      label = _ref.label,
+      description = _ref.description;
+
+  var _useContext = useContext(FormContext),
+      submitText = _useContext.submitText,
+      submitting = _useContext.submitting,
+      showSubmitButton = _useContext.showSubmitButton,
+      form = _useContext.form,
+      registerDependencies = _useContext.registerDependencies;
+
+  var _useContext2 = useContext(LocaleContext),
+      formatMessage = _useContext2.formatMessage;
+
+  var pName = useMemo(function () {
+    return calcNamePath(parentName, name);
+  }, [parentName, name]);
+
+  var _useReducer = useReducer(function (r) {
+    return r + 1;
+  }, 0),
+      _useReducer2 = _slicedToArray(_useReducer, 2),
+      _ = _useReducer2[0],
+      dispatch = _useReducer2[1];
+
+  var buttonDisabled = getButtonDisabledState && form && getButtonDisabledState(form);
+  useEffect(function () {
+    var subscribe = Boolean(shouldRender) || Boolean(getButtonDisabledState);
+
+    if (subscribe) {
+      registerDependencies('SUBSCRIBE_ALL', dispatch);
+    }
+  }, []);
+
+  var tranformChildren = function tranformChildren() {
+    if (Array.isArray(children)) {
+      return children.map(function (c, index) {
+        var _c$type;
+
+        if ((c === null || c === void 0 ? void 0 : (_c$type = c.type) === null || _c$type === void 0 ? void 0 : _c$type.displayName) === 'Igloo_Free_Form_Item') {
+          return /*#__PURE__*/cloneElement(c, _objectSpread(_objectSpread({}, c.props), {}, {
+            parentName: pName,
+            key: c.props.key || index
+          }));
+        }
+      });
+    }
+
+    return /*#__PURE__*/isValidElement(children) ? /*#__PURE__*/cloneElement(children, _objectSpread(_objectSpread({}, children.props), {}, {
+      parentName: pName
+    })) : children;
+  };
+
+  return _jsxs("div", Object.assign({
+    className: 'igloo-page-container'
+  }, {
+    children: [_jsx(Typography, Object.assign({
+      level: "h3b",
+      wrapElement: "div",
+      style: {
+        marginBottom: 8
+      }
+    }, {
+      children: label
+    }), void 0), _jsx(Typography, Object.assign({
+      level: "body1",
+      wrapElement: "div",
+      style: {
+        marginBottom: 24,
+        color: '#666666'
+      }
+    }, {
+      children: description
+    }), void 0), _jsx("div", Object.assign({
+      className: 'igloo-page-content'
+    }, {
+      children: _jsx(_Row, Object.assign({
+        gutter: [32, 24]
+      }, {
+        children: tranformChildren()
+      }), void 0)
+    }), void 0), showFooter && showSubmitButton && _jsxs("div", Object.assign({
+      className: 'igloo-page-footer'
+    }, {
+      children: [buttonPlacement === 'right' && _jsx("div", {}, void 0), _jsx(_Form.Item, {
+        children: _jsx(Button, Object.assign({
+          type: "primary",
+          htmlType: "submit",
+          className: 'igloo-page-submit-button',
+          loading: submitting,
+          disabled: buttonDisabled
+        }, {
+          children: submitText || formatMessage({
+            id: 'Submit'
+          })
+        }), void 0)
+      }, void 0), buttonPlacement === 'left' && _jsx("div", {}, void 0)]
+    }), void 0)]
+  }), void 0);
+};
+
+Page.displayName = 'Igloo_Free_Form_Page';
+export default Page;

package/es/free-form/page/style/index.d.ts

@@ -0,0 +1 @@
+import './index.less';

package/es/free-form/page/style/index.js

@@ -0,0 +1 @@
+import './index.less';

package/es/free-form/page/style/index.less

@@ -0,0 +1,55 @@
+.igloo-page-container {
+  width: 100%;
+  background-color: #fff;
+  padding: 32px;
+
+  .igloo-page-content {
+    width: 100%;
+  }
+
+  .igloo-page-footer {
+    margin-top: 24px;
+    display: flex;
+    justify-content: space-between;
+
+    .ant-form-item {
+      margin: 0;
+    }
+
+    .igloo-page-cancel-button {
+      min-width: 196px;
+    }
+
+    .igloo-page-submit-button {
+      min-width: 196px;
+    }
+  }
+}
+
+@media screen and (max-width: 768px) {
+  .igloo-page-container {
+    width: 100%;
+    background-color: #fff;
+    padding: 24px 16px;
+
+    .igloo-page-content {
+      width: 100%;
+    }
+
+    .igloo-page-footer {
+      display: flex;
+      flex-direction: column-reverse;
+      row-gap: 16px;
+
+      .igloo-page-cancel-button {
+        min-width: none;
+        width: 100%;
+      }
+
+      .igloo-page-submit-button {
+        min-width: none;
+        width: 100%;
+      }
+    }
+  }
+}

package/es/free-form/style/index.d.ts

@@ -0,0 +1 @@
+import './index.less';

package/es/free-form/style/index.js

@@ -0,0 +1 @@
+import './index.less';

package/es/free-form/style/index.less

@@ -0,0 +1,40 @@
+//form
+.ant-form-item-label {
+  color: #666666;
+
+  & > label {
+    width: 100%;
+
+    &::before {
+      display: none !important;
+    }
+  }
+}
+
+.ant-form-item-explain,
+.ant-form-item-extra {
+  font-size: 14px;
+  margin-top: 6px;
+  min-height: unset !important;
+  font-style: italic;
+}
+
+.ant-form-item-extra {
+  font-style: italic;
+}
+
+.ant-form-item-explain-error + .ant-form-item-extra {
+  margin-top: 4px;
+}
+
+.ant-form-item-with-help {
+  margin-bottom: 24px;
+}
+
+.ant-form-item-explain.ant-form-item-explain-error {
+  font-style: normal;
+  font-weight: normal;
+  font-size: 14px;
+  line-height: 20px;
+  color: @error-color;
+}

package/es/free-form/utils.d.ts

@@ -0,0 +1,73 @@
+import { FormInstance } from 'antd/es/form';
+import { FormItemConfig, FormItemExtraConfig, FormItemName, FormItemCopyValue, FormItemSelectValue, FormItemAssert } from '../types';
+import { NamePath } from 'antd/es/form/interface';
+export declare const calcNamePath: (parentName: FormItemName | undefined, name: FormItemName | undefined) => (string | number)[];
+export declare const testAssert: (form: FormInstance, assert: FormItemAssert) => boolean;
+export declare const calcFormItemProps: (config: FormItemConfig, extraProps: FormItemExtraConfig, form?: FormInstance<any> | undefined, parentName?: NamePath | undefined) => {
+    colProps: {
+        span: number;
+        xs: number;
+        sm: number;
+        md: number;
+        halfRow: boolean | undefined;
+    };
+    formItemProps: {
+        name: (string | number)[];
+        className: string | undefined;
+        initialValue: any;
+        copiedValue: {
+            copied: boolean;
+            value?: undefined;
+            disabled?: undefined;
+        } | {
+            copied: boolean;
+            value: any;
+            disabled: boolean | undefined;
+        };
+        selectedValue: {
+            selected: boolean;
+            value?: undefined;
+            disabled?: undefined;
+        } | {
+            selected: boolean;
+            value: any;
+            disabled: boolean | undefined;
+        };
+        normalize: ((value: any, prevValue: any, allValues: import("rc-field-form/lib/interface").Store) => any) | undefined;
+        rules: import("rc-field-form/lib/interface").Rule[];
+        label: JSX.Element | null;
+        getValueFromEvent: ((...args: import("rc-field-form/lib/interface").EventArgs) => any) | undefined;
+        getValueProps: ((value: any) => object) | undefined;
+        extra: JSX.Element | null | undefined;
+        help: {} | null | undefined;
+        valuePropName: string | undefined;
+        messageVariables: {
+            label: string;
+        };
+    };
+    elementProps: {
+        [key: string]: any;
+    };
+    display: boolean;
+    previewFormater: ((value: any) => any) | undefined;
+};
+export declare const calcDisabled: (disabled?: boolean | FormItemAssert | FormItemAssert[] | undefined, form?: FormInstance<any> | undefined) => boolean;
+export declare const calcCopyValue: (copyValue?: FormItemCopyValue | undefined, form?: FormInstance<any> | undefined) => {
+    copied: boolean;
+    value?: undefined;
+    disabled?: undefined;
+} | {
+    copied: boolean;
+    value: any;
+    disabled: boolean | undefined;
+};
+export declare const calcSelectValue: (selectValue?: FormItemSelectValue[] | undefined, form?: FormInstance<any> | undefined) => {
+    selected: boolean;
+    value?: undefined;
+    disabled?: undefined;
+} | {
+    selected: boolean;
+    value: any;
+    disabled: boolean | undefined;
+};
+export declare const calcShouldRender: (dependencies?: NamePath[], asserts?: FormItemAssert[], shouldRender?: ((form?: FormInstance<any> | undefined) => boolean) | undefined, form?: FormInstance<any> | undefined) => boolean;

package/es/free-form/utils.js

@@ -0,0 +1,370 @@
+var _excluded = ["type", "name", "required", "showOptional", "rules", "initialValue", "normalize", "mergeRules", "getValueFromEvent", "getValueProps", "extra", "help", "label", "extraLabel", "copyValue", "selectValue", "span", "halfRow", "fullRow", "valuePropName", "dependencies", "asserts", "messageVariables", "requiredMessage", "previewFormater", "disabled", "ignore", "shouldRender", "valueFormater"],
+    _excluded2 = ["initialValue", "normalize", "rules", "extra", "help", "getValueFromEvent", "span", "valuePropName", "fullRow", "halfRow", "messageVariables", "requiredMessage", "previewFormater", "valueFormater", "required", "requiredMark", "className"];
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import invariant from 'invariant';
+import Typography from '../typography';
+import formatMessage from '../locale/formatted-message';
+export var calcNamePath = function calcNamePath(parentName, name) {
+  var names = [];
+
+  if (parentName) {
+    names.push(parentName);
+  }
+
+  if (name) {
+    names.push(name);
+  }
+
+  return names.flat();
+};
+export var testAssert = function testAssert(form, assert) {
+  var field = assert.field,
+      value = assert.value,
+      _assert$operation = assert.operation,
+      operation = _assert$operation === void 0 ? 'eq' : _assert$operation;
+  var v = form.getFieldValue(field);
+
+  switch (operation) {
+    case 'ne':
+      if (v === value) return false;
+      break;
+
+    case 'in':
+      if (!Array.isArray(value) || !value.includes(v)) return false;
+      break;
+
+    case 'ni':
+      if (Array.isArray(value) && value.includes(v)) return false;
+      break;
+
+    case 'co':
+      if (!Array.isArray(v) || !v.includes(value)) return false;
+      break;
+
+    case 'nc':
+      if (Array.isArray(v) && v.includes(value)) return false;
+      break;
+
+    case 'lt':
+      if (v === undefined || v >= value) return false;
+      break;
+
+    case 'le':
+      if (v === undefined || v > value) return false;
+      break;
+
+    case 'gt':
+      if (v === undefined || v <= value) return false;
+      break;
+
+    case 'ge':
+      if (v === undefined || v < value) return false;
+      break;
+
+    case 'eq':
+    default:
+      if (v !== value) return false;
+  }
+
+  return true;
+};
+export var calcFormItemProps = function calcFormItemProps(config, extraProps, form, parentName) {
+  var type = config.type,
+      nameProp = config.name,
+      _config$required = config.required,
+      required = _config$required === void 0 ? true : _config$required,
+      _config$showOptional = config.showOptional,
+      showOptional = _config$showOptional === void 0 ? false : _config$showOptional,
+      _config$rules = config.rules,
+      propsRules = _config$rules === void 0 ? [] : _config$rules,
+      initialValue = config.initialValue,
+      normalize = config.normalize,
+      _config$mergeRules = config.mergeRules,
+      mergeRules = _config$mergeRules === void 0 ? true : _config$mergeRules,
+      getValueFromEvent = config.getValueFromEvent,
+      getValueProps = config.getValueProps,
+      extra = config.extra,
+      help = config.help,
+      label = config.label,
+      extraLabel = config.extraLabel,
+      copyValue = config.copyValue,
+      selectValue = config.selectValue,
+      span = config.span,
+      halfRow = config.halfRow,
+      fullRow = config.fullRow,
+      valuePropName = config.valuePropName,
+      _config$dependencies = config.dependencies,
+      dependencies = _config$dependencies === void 0 ? [] : _config$dependencies,
+      _config$asserts = config.asserts,
+      asserts = _config$asserts === void 0 ? [] : _config$asserts,
+      messageVariables = config.messageVariables,
+      requiredMessage = config.requiredMessage,
+      previewFormater = config.previewFormater,
+      disabled = config.disabled,
+      ignore = config.ignore,
+      shouldRender = config.shouldRender,
+      valueFormater = config.valueFormater,
+      rest = _objectWithoutProperties(config, _excluded);
+
+  invariant(nameProp || type === 'Divider' || type === 'Section' || !type, "name property is required for form item config (type: ".concat(type, ")"));
+  invariant(!previewFormater || typeof previewFormater === 'function', 'previewFormater property should be a function');
+  invariant(!shouldRender || typeof shouldRender === 'function', 'shouldRender property should be a function');
+
+  var extraInitialValue = extraProps.initialValue,
+      extraNormalize = extraProps.normalize,
+      _extraProps$rules = extraProps.rules,
+      extraRules = _extraProps$rules === void 0 ? [] : _extraProps$rules,
+      extraExtra = extraProps.extra,
+      extraHelp = extraProps.help,
+      extraGetValueFromEvent = extraProps.getValueFromEvent,
+      extraSpan = extraProps.span,
+      extraValuePropName = extraProps.valuePropName,
+      extraFullRow = extraProps.fullRow,
+      extraHalfRow = extraProps.halfRow,
+      extraMessageVariables = extraProps.messageVariables,
+      extraRequiredMessage = extraProps.requiredMessage,
+      extraPreviewFormater = extraProps.previewFormater,
+      _extraProps$valueForm = extraProps.valueFormater,
+      extraValueFormater = _extraProps$valueForm === void 0 ? function (value) {
+    return value;
+  } : _extraProps$valueForm,
+      _extraProps$required = extraProps.required,
+      extraRequired = _extraProps$required === void 0 ? true : _extraProps$required,
+      _extraProps$requiredM = extraProps.requiredMark,
+      requiredMark = _extraProps$requiredM === void 0 ? false : _extraProps$requiredM,
+      className = extraProps.className,
+      extraRest = _objectWithoutProperties(extraProps, _excluded2);
+
+  var rules = required === true && extraRequired ? [{
+    required: true,
+    message: requiredMessage || extraRequiredMessage
+  }].concat(_toConsumableArray(propsRules)) : propsRules;
+
+  if (mergeRules) {
+    rules.push.apply(rules, _toConsumableArray(extraRules));
+  }
+
+  var isRequired = required || rules.find(function (rule) {
+    return rule.required;
+  });
+  var name = calcNamePath(parentName, nameProp);
+  var copiedValue = calcCopyValue(copyValue, form);
+  var selectedValue = calcSelectValue(selectValue, form);
+  var elementProps = {};
+  Object.keys(_objectSpread(_objectSpread({}, extraRest), rest)).forEach(function (key) {
+    elementProps[key.replace('element-', '')] = rest[key];
+  });
+  elementProps.disabled = calcDisabled(disabled, form) || copiedValue.disabled || selectedValue.disabled;
+  return {
+    colProps: {
+      span: extraFullRow && fullRow === undefined || fullRow || extraHalfRow && halfRow === undefined || halfRow ? 24 : span || extraSpan || 12,
+      xs: 24,
+      sm: 24,
+      md: extraFullRow && fullRow === undefined || fullRow || extraHalfRow && halfRow === undefined || halfRow ? 24 : span || 12,
+      halfRow: halfRow === undefined ? extraHalfRow : halfRow
+    },
+    formItemProps: {
+      name: name,
+      className: className,
+      initialValue: (valueFormater || extraValueFormater)(initialValue || extraInitialValue),
+      copiedValue: copiedValue,
+      selectedValue: selectedValue,
+      normalize: normalize || extraNormalize,
+      rules: rules,
+      label: label ? _jsxs("div", Object.assign({
+        className: "igloo-form-label"
+      }, {
+        children: [_jsxs("div", Object.assign({
+          className: "igloo-form-label-text"
+        }, {
+          children: [_jsx(Typography, Object.assign({
+            level: "body1"
+          }, {
+            children: label
+          }), void 0), isRequired && requiredMark && _jsx("span", Object.assign({
+            className: "igloo-form-label-required"
+          }, {
+            children: "*"
+          }), void 0), showOptional && _jsxs("span", Object.assign({
+            className: "igloo-form-label-optional"
+          }, {
+            children: ["(", formatMessage({
+              id: 'Optional'
+            }), ")"]
+          }), void 0)]
+        }), void 0), extraLabel && _jsx("div", Object.assign({
+          className: "igloo-form-label-extra"
+        }, {
+          children: typeof extraLabel === 'function' ? extraLabel(form) : extraLabel
+        }), void 0)]
+      }), void 0) : null,
+      getValueFromEvent: getValueFromEvent || extraGetValueFromEvent,
+      getValueProps: getValueProps,
+      extra: (extra || extraExtra) && _jsx(Typography, Object.assign({
+        level: "caption2"
+      }, {
+        children: extra || extraExtra
+      }), void 0),
+      help: help || extraHelp,
+      valuePropName: valuePropName || extraValuePropName,
+      messageVariables: _objectSpread({
+        label: label
+      }, messageVariables || extraMessageVariables)
+    },
+    elementProps: elementProps,
+    display: !ignore && calcShouldRender(dependencies, asserts, shouldRender, form),
+    previewFormater: previewFormater || extraPreviewFormater
+  };
+};
+export var calcDisabled = function calcDisabled(disabled, form) {
+  if (!form || !disabled) return false;
+  if (typeof disabled === 'boolean') return disabled;
+
+  if (Array.isArray(disabled)) {
+    var _iterator = _createForOfIteratorHelper(disabled),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var assert = _step.value;
+
+        if (!testAssert(form, assert)) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return true;
+  }
+
+  return testAssert(form, disabled);
+};
+export var calcCopyValue = function calcCopyValue(copyValue, form) {
+  if (!form) return {
+    copied: false
+  };
+  if (!copyValue) return {
+    copied: false
+  };
+  var copyFrom = copyValue.copyFrom,
+      assert = copyValue.assert,
+      disabled = copyValue.disabled;
+  return testAssert(form, assert) ? {
+    copied: true,
+    value: form.getFieldValue(copyFrom),
+    disabled: disabled
+  } : {
+    copied: false
+  };
+};
+export var calcSelectValue = function calcSelectValue(selectValue, form) {
+  if (!form) return {
+    selected: false
+  };
+  if (!selectValue) return {
+    selected: false
+  };
+  invariant(Array.isArray(selectValue), 'selectValue property should be an array.');
+
+  var _iterator2 = _createForOfIteratorHelper(selectValue),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var select = _step2.value;
+      var assert = select.assert,
+          value = select.value,
+          disabled = select.disabled;
+
+      if (testAssert(form, assert)) {
+        return {
+          selected: true,
+          value: value,
+          disabled: disabled
+        };
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  return {
+    selected: false
+  };
+};
+export var calcShouldRender = function calcShouldRender() {
+  var dependencies = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var asserts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var shouldRender = arguments.length > 2 ? arguments[2] : undefined;
+  var form = arguments.length > 3 ? arguments[3] : undefined;
+  if (!form) return true;
+
+  var _iterator3 = _createForOfIteratorHelper(dependencies),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var dep = _step3.value;
+
+      if (!form.getFieldValue(dep)) {
+        return false;
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+
+  var _iterator4 = _createForOfIteratorHelper(asserts),
+      _step4;
+
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var assert = _step4.value;
+      var rst = testAssert(form, assert);
+      if (!rst) return rst;
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+
+  if (typeof shouldRender === 'function' && !shouldRender(form)) {
+    return false;
+  }
+
+  return true;
+};