iglooform 2.3.3 → 2.3.7

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+
+require("./index.less");

package/lib/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/lib/free-form/style/index.d.ts

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

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

@@ -0,0 +1,3 @@
+"use strict";
+
+require("./index.less");

package/lib/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/lib/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/lib/free-form/utils.js

@@ -0,0 +1,403 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcShouldRender = exports.calcSelectValue = exports.calcCopyValue = exports.calcDisabled = exports.calcFormItemProps = exports.testAssert = exports.calcNamePath = void 0;
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+var _invariant = _interopRequireDefault(require("invariant"));
+
+var _typography = _interopRequireDefault(require("../typography"));
+
+var _formattedMessage = _interopRequireDefault(require("../locale/formatted-message"));
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+var calcNamePath = function calcNamePath(parentName, name) {
+  var names = [];
+
+  if (parentName) {
+    names.push(parentName);
+  }
+
+  if (name) {
+    names.push(name);
+  }
+
+  return names.flat();
+};
+
+exports.calcNamePath = calcNamePath;
+
+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;
+};
+
+exports.testAssert = testAssert;
+
+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);
+
+  (0, _invariant.default)(nameProp || type === 'Divider' || type === 'Section' || !type, "name property is required for form item config (type: ".concat(type, ")"));
+  (0, _invariant.default)(!previewFormater || typeof previewFormater === 'function', 'previewFormater property should be a function');
+  (0, _invariant.default)(!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 ? (0, _jsxRuntime.jsxs)("div", Object.assign({
+        className: "igloo-form-label"
+      }, {
+        children: [(0, _jsxRuntime.jsxs)("div", Object.assign({
+          className: "igloo-form-label-text"
+        }, {
+          children: [(0, _jsxRuntime.jsx)(_typography.default, Object.assign({
+            level: "body1"
+          }, {
+            children: label
+          }), void 0), isRequired && requiredMark && (0, _jsxRuntime.jsx)("span", Object.assign({
+            className: "igloo-form-label-required"
+          }, {
+            children: "*"
+          }), void 0), showOptional && (0, _jsxRuntime.jsxs)("span", Object.assign({
+            className: "igloo-form-label-optional"
+          }, {
+            children: ["(", (0, _formattedMessage.default)({
+              id: 'Optional'
+            }), ")"]
+          }), void 0)]
+        }), void 0), extraLabel && (0, _jsxRuntime.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) && (0, _jsxRuntime.jsx)(_typography.default, 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
+  };
+};
+
+exports.calcFormItemProps = calcFormItemProps;
+
+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);
+};
+
+exports.calcDisabled = calcDisabled;
+
+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
+  };
+};
+
+exports.calcCopyValue = calcCopyValue;
+
+var calcSelectValue = function calcSelectValue(selectValue, form) {
+  if (!form) return {
+    selected: false
+  };
+  if (!selectValue) return {
+    selected: false
+  };
+  (0, _invariant.default)(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
+  };
+};
+
+exports.calcSelectValue = calcSelectValue;
+
+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;
+};
+
+exports.calcShouldRender = calcShouldRender;