@4399ywkf/design 2.1.0 → 2.1.1

package/dist/FormDesigner/utils/index.js

@@ -0,0 +1,706 @@
+var _excluded = ["propsSchema"],
+  _excluded2 = ["schema"],
+  _excluded3 = ["onChange", "value", "defaultValue", "schema"];
+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; }
+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(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import deepClone from 'clone';
+import { nanoid } from 'nanoid';
+function stringContains(str, text) {
+  return str.indexOf(text) > -1;
+}
+export var isObject = function isObject(a) {
+  return stringContains(Object.prototype.toString.call(a), 'Object');
+};
+
+// '3' => true, 3 => true, undefined => false
+export function isLooselyNumber(num) {
+  if (typeof num === 'number') return true;
+  if (typeof num === 'string') {
+    return !Number.isNaN(Number(num));
+  }
+  return false;
+}
+export function isCssLength(str) {
+  if (typeof str !== 'string') return false;
+  return str.match(/^([0-9])*(%|px|rem|em)$/i);
+}
+
+// 深度对比
+export function isDeepEqual(param1, param2) {
+  if (param1 === undefined && param2 === undefined) return true;else if (param1 === undefined || param2 === undefined) return false;
+  if (param1 === null && param2 === null) return true;else if (param1 === null || param2 === null) return false;else if (param1.constructor !== param2.constructor) return false;
+  if (param1.constructor === Array) {
+    if (param1.length !== param2.length) return false;
+    for (var i = 0; i < param1.length; i++) {
+      if (param1[i].constructor === Array || param1[i].constructor === Object) {
+        if (!isDeepEqual(param1[i], param2[i])) return false;
+      } else if (param1[i] !== param2[i]) return false;
+    }
+  } else if (param1.constructor === Object) {
+    if (Object.keys(param1).length !== Object.keys(param2).length) return false;
+    for (var _i = 0; _i < Object.keys(param1).length; _i++) {
+      var key = Object.keys(param1)[_i];
+      if (param1[key] && typeof param1[key] !== 'number' && (param1[key].constructor === Array || param1[key].constructor === Object)) {
+        if (!isDeepEqual(param1[key], param2[key])) return false;
+      } else if (param1[key] !== param2[key]) return false;
+    }
+  } else if (param1.constructor === String || param1.constructor === Number) {
+    return param1 === param2;
+  }
+  return true;
+}
+
+// ----------------- schema 相关
+
+// 合并propsSchema和UISchema。由于两者的逻辑相关性，合并为一个大schema能简化内部处理
+export function combineSchema() {
+  var propsSchema = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var uiSchema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var propList = getChildren(propsSchema);
+  var newList = propList.map(function (p) {
+    var name = p.name;
+    var _p$schema = p.schema,
+      type = _p$schema.type,
+      options = _p$schema.enum,
+      properties = _p$schema.properties,
+      items = _p$schema.items;
+    var isObj = type === 'object' && properties;
+    var isArr = type === 'array' && items && !options; // enum + array 代表的多选框，没有sub
+    var ui = name && uiSchema[p.name];
+    if (!ui) {
+      return p;
+    }
+    // 如果是list，递归合并items
+    if (isArr) {
+      var newItems = combineSchema(items, ui.items || {});
+      return _objectSpread(_objectSpread({}, p), {}, {
+        schema: _objectSpread(_objectSpread(_objectSpread({}, p.schema), ui), {}, {
+          items: newItems
+        })
+      });
+    }
+    // object递归合并整个schema
+    if (isObj) {
+      var newSchema = combineSchema(p.schema, ui);
+      return _objectSpread(_objectSpread({}, p), {}, {
+        schema: newSchema
+      });
+    }
+    return _objectSpread(_objectSpread({}, p), {}, {
+      schema: _objectSpread(_objectSpread({}, p.schema), ui)
+    });
+  });
+  var newObj = {};
+  newList.forEach(function (s) {
+    newObj[s.name] = s.schema;
+  });
+  var topLevelUi = {};
+  Object.keys(uiSchema).forEach(function (key) {
+    if (typeof key === 'string' && key.substring(0, 3) === 'ui:') {
+      topLevelUi[key] = uiSchema[key];
+    }
+  });
+  if (isEmpty(newObj)) {
+    return _objectSpread(_objectSpread({}, propsSchema), topLevelUi);
+  }
+  return _objectSpread(_objectSpread(_objectSpread({}, propsSchema), topLevelUi), {}, {
+    properties: newObj
+  });
+}
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+
+// 获得propsSchema的children
+function getChildren(schema) {
+  if (!schema) return [];
+  var properties = schema.properties,
+    items = schema.items,
+    type = schema.type;
+  if (!properties && !items) {
+    return [];
+  }
+  var schemaSubs = {};
+  if (type === 'object') {
+    schemaSubs = properties;
+  }
+  if (type === 'array') {
+    schemaSubs = items;
+  }
+  return Object.keys(schemaSubs).map(function (name) {
+    return {
+      schema: schemaSubs[name],
+      name: name
+    };
+  });
+}
+
+// 判断schema的值是是否是"函数"
+// JSON无法使用函数值的参数，所以使用"{{...}}"来标记为函数，也可使用@标记，不推荐。
+export function isFunction(func) {
+  if (typeof func === 'function') {
+    return true;
+  }
+  if (typeof func === 'string' && func.substring(0, 1) === '@') {
+    return func.substring(1);
+  }
+  if (typeof func === 'string' && func.substring(0, 2) === '{{' && func.substring(func.length - 2, func.length) === '}}') {
+    return func.substring(2, func.length - 2);
+  }
+  return false;
+}
+
+// 判断schema中是否有属性值是函数表达式
+export function isFunctionSchema(schema) {
+  return Object.keys(schema).some(function (key) {
+    if (typeof schema[key] === 'function') {
+      return true;
+    } else if (typeof schema[key] === 'string') {
+      return !!isFunction(schema[key]);
+    } else if (_typeof(schema[key]) === 'object') {
+      return isFunctionSchema(schema[key]);
+    } else {
+      return false;
+    }
+  });
+}
+
+// 后面三个参数都是内部递归使用的，将schema的树形结构扁平化成一层, 每个item的结构
+// {
+//   parent: '#',
+//   schema: ...,
+//   children: []
+// }
+export function flattenSchema(schema) {
+  var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '#';
+  var parent = arguments.length > 2 ? arguments[2] : undefined;
+  var result = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var _schema = deepClone(schema);
+  if (!_schema.$id) {
+    _schema.$id = name; // 给生成的schema添加一个唯一标识，方便从schema中直接读取
+  }
+  var children = [];
+  var isObj = _schema.type === 'object' && _schema.properties;
+  var isList = _schema.type === 'array' && _schema.items && _schema.items.properties;
+  if (isObj) {
+    Object.entries(_schema.properties).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      var uniqueName = name + '/' + key;
+      children.push(uniqueName);
+      flattenSchema(value, uniqueName, name, result);
+    });
+    delete _schema.properties;
+  }
+  if (isList) {
+    Object.entries(_schema.items.properties).forEach(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+        key = _ref4[0],
+        value = _ref4[1];
+      var uniqueName = name + '/' + key;
+      children.push(uniqueName);
+      flattenSchema(value, uniqueName, name, result);
+    });
+    delete _schema.items.properties;
+  }
+  if (_schema.type) {
+    result[name] = {
+      parent: parent,
+      schema: _schema,
+      children: children
+    };
+  }
+  return result;
+}
+export var getKeyFromUniqueId = function getKeyFromUniqueId() {
+  var uniqueId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '#';
+  var arr = uniqueId.split('/');
+  return arr[arr.length - 1];
+};
+export var changeKeyFromUniqueId = function changeKeyFromUniqueId() {
+  var uniqueId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '#';
+  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'something';
+  var arr = uniqueId.split('/');
+  if (typeof key === 'string' || typeof key === 'number') {
+    arr[arr.length - 1] = String(key);
+  }
+  return arr.join('/');
+};
+
+// final = true 用于最终的导出的输出
+// 几种特例：
+// 1. 删除时值删除了item，没有删除和parent的关联，也没有删除children，所以要在解析这步来兜住 (所有的解析都是)
+// 2. 修改$id的情况, 修改的是schema内的$id, 解析的时候要把schema.$id 作为真正的id (final = true的解析)
+export function idToSchema(flatten) {
+  var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '#';
+  var final = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var schema = {};
+  var _item = flatten[id];
+  var item = deepClone(_item);
+  if (item) {
+    schema = _objectSpread({}, item.schema);
+    // 最终输出去掉 $id
+    if (final) {
+      if (schema.$id) delete schema.$id;
+    }
+    if (item.children.length > 0) {
+      item.children.forEach(function (child) {
+        var childId = child;
+        // TODO: 这个情况会出现吗？return会有问题吗？
+        if (!flatten[child]) {
+          return;
+        }
+        // 最终输出将所有的 key 值改了
+        try {
+          if (final) {
+            childId = flatten[child].schema.$id;
+          }
+        } catch (error) {
+          console.error(error, 'catch');
+        }
+        var key = getKeyFromUniqueId(childId);
+        if (schema.type === 'object') {
+          if (!schema.properties) {
+            schema.properties = {};
+          }
+          schema.properties[key] = idToSchema(flatten, child, final);
+        }
+        if (schema.type === 'array' && schema.items && schema.items.type === 'object') {
+          if (!schema.items.properties) {
+            schema.items.properties = {};
+          }
+          schema.items.properties[key] = idToSchema(flatten, child, final);
+        }
+      });
+    } else {
+      if (schema.type === 'object' && !schema.properties) {
+        schema.properties = {};
+      }
+      if (schema.type === 'array' && schema.items && schema.items.type === 'object' && !schema.items.properties) {
+        schema.items.properties = {};
+      }
+    }
+  }
+  return schema;
+}
+export var copyItem = function copyItem(flatten, $id, getId) {
+  var newFlatten = _objectSpread({}, flatten);
+  try {
+    var item = flatten[$id];
+    var newId = getId($id);
+    var siblings = newFlatten[item.parent].children;
+    var idx = siblings.findIndex(function (x) {
+      return x === $id;
+    });
+    siblings.splice(idx + 1, 0, newId);
+    newFlatten[newId] = deepClone(newFlatten[$id]);
+    newFlatten[newId].schema.$id = newId;
+    return [newFlatten, newId];
+  } catch (error) {
+    console.error(error, 'catcherror');
+    return [flatten, $id];
+  }
+};
+
+// Left 点击添加 item
+export var addItem = function addItem(_ref5) {
+  var selected = _ref5.selected,
+    name = _ref5.name,
+    schema = _ref5.schema,
+    flatten = _ref5.flatten,
+    fixedName = _ref5.fixedName,
+    getId = _ref5.getId;
+  var _selected = selected || '#';
+  var newId;
+  // string第一个是0，说明点击了object、list的里侧
+  if (_selected && _selected[0] === '0' || _selected === '#') {
+    var _newFlatten = _objectSpread({}, flatten);
+    try {
+      var oldId = _selected.substring(1);
+      newId = _selected === '#' ? "#/" : "".concat(oldId, "/");
+      if (!fixedName) {
+        newId += getId(name);
+      } else {
+        newId += name;
+      }
+      if (_selected === '#') {
+        oldId = '#';
+      }
+      var siblings = _newFlatten[oldId].children;
+      siblings.push(newId);
+      var newItem = {
+        parent: oldId,
+        schema: _objectSpread(_objectSpread({}, schema), {}, {
+          $id: newId
+        }),
+        data: undefined,
+        children: []
+      };
+      _newFlatten[newId] = newItem;
+    } catch (error) {
+      console.error(error, 'catch');
+    }
+    return {
+      newId: newId,
+      newFlatten: _newFlatten
+    };
+  }
+  var _name = fixedName ? name : getId(name);
+  var idArr = selected.split('/');
+  idArr.pop();
+  idArr.push(_name);
+  newId = idArr.join('/');
+  var newFlatten = _objectSpread({}, flatten);
+  try {
+    var item = newFlatten[selected];
+    var _siblings = newFlatten[item.parent].children;
+    var idx = _siblings.findIndex(function (x) {
+      return x === selected;
+    });
+    _siblings.splice(idx + 1, 0, newId);
+    var _newItem = {
+      parent: item.parent,
+      schema: _objectSpread(_objectSpread({}, schema), {}, {
+        $id: newId
+      }),
+      data: undefined,
+      children: []
+    };
+    newFlatten[newId] = _newItem;
+  } catch (error) {
+    console.error(error);
+  }
+  return {
+    newId: newId,
+    newFlatten: newFlatten
+  };
+};
+
+// position 代表 drop 在元素的哪里: 'up' 上 'down' 下 'inside' 内部
+export var dropItem = function dropItem(_ref6) {
+  var dragId = _ref6.dragId,
+    dragItem = _ref6.dragItem,
+    dropId = _ref6.dropId,
+    position = _ref6.position,
+    flatten = _ref6.flatten;
+  var _position = dropId === '#' ? 'inside' : position;
+  var newFlatten = _objectSpread({}, flatten);
+  // 会动到三块数据，dragItem, dragParent, dropParent. 其中dropParent可能就是dropItem（inside的情况）
+  if (dragItem) {
+    newFlatten[dragId] = dragItem;
+  }
+  var _dragItem = dragItem || newFlatten[dragId];
+  var dropItemData = newFlatten[dropId];
+  var dropParent = dropItemData;
+  if (_position !== 'inside') {
+    var parentId = dropItemData.parent;
+    dropParent = newFlatten[parentId];
+  }
+  // TODO: 这块的体验，现在这样兜底了，但是drag起一个元素了，应该让原本变空
+  if (dropId.indexOf(dragId) > -1) {
+    return [newFlatten, dragId];
+  }
+  var newId = dragId;
+  try {
+    var newParentId = dropParent.schema.$id;
+    newId = newId.replace(_dragItem.parent, newParentId);
+  } catch (error) {}
+
+  // dragParent 的 children 删除 dragId
+  try {
+    var dragParent = newFlatten[_dragItem.parent];
+    var idx = dragParent.children.indexOf(dragId);
+    if (idx > -1 && !dragItem) {
+      dragParent.children.splice(idx, 1);
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  try {
+    // dropParent 的 children 添加 dragId
+    var newChildren = dropParent.children || []; // 要考虑children为空，inside的情况
+    var _idx = newChildren.indexOf(dropId);
+    switch (_position) {
+      case 'up':
+        newChildren.splice(_idx, 0, dragId);
+        break;
+      case 'down':
+        newChildren.splice(_idx + 1, 0, dragId);
+        break;
+      default:
+        // inside 作为 default 情况
+        newChildren.push(dragId);
+        break;
+    }
+    dropParent.children = newChildren;
+  } catch (error) {
+    console.error(error);
+  }
+  _dragItem.parent = dropParent.$id;
+  return [newFlatten, newId];
+};
+
+// TODO: 没有考虑list的情况
+export var dataToFlatten = function dataToFlatten(flatten, data) {
+  // R15: data 为空时不能丢弃 flatten（schema），否则下游 idToSchema('#') 会崩。
+  // 仅在 flatten 不存在时短路；data 缺省用 {}，照常返回带 schema 的 flatten。
+  if (!flatten) return {};
+  var _data = data || {};
+  Object.entries(flatten).forEach(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 1),
+      id = _ref8[0];
+    flatten[id].data = getDataById(_data, id);
+  });
+  return flatten;
+};
+export var flattenToData = function flattenToData(flatten) {
+  var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '#';
+  try {
+    var result = flatten[id].data;
+    var ids = Object.keys(flatten);
+    var childrenIds = ids.filter(function (item) {
+      var lengthOfId = id.split('/').length;
+      var lengthOfChild = item.split('/').length;
+      return item.indexOf(id) > -1 && lengthOfChild > lengthOfId;
+    });
+    if (childrenIds && childrenIds.length > 0) {
+      var type = flatten[id].schema.type;
+      if (result === undefined) {
+        // TODO: 这个是简化的逻辑，在编辑器模型下，list和object都是object结构
+        if (type === 'object') {
+          result = {};
+        } else if (type === 'array') {
+          result = [{}];
+        }
+      }
+      childrenIds.forEach(function (c) {
+        var lengthOfId = id.split('/').length;
+        var lengthOfChild = c.split('/').length;
+        // 只比他长1，是直属的child
+        if (lengthOfChild === lengthOfId + 1) {
+          var cData = flattenToData(flatten, c);
+          var cKey = getKeyFromUniqueId(c);
+          if (cData === undefined) return result;
+          if (type === 'array') {
+            result[0][cKey] = cData;
+          } else {
+            result[cKey] = cData;
+          }
+        }
+      });
+    }
+    return result;
+  } catch (error) {
+    return undefined;
+  }
+};
+
+// 例如当前item的id = '#/obj/input'  propName: 'labelWidth' 往上一直找，直到找到第一个不是undefined的值
+export var getParentProps = function getParentProps(propName, id, flatten) {
+  try {
+    var item = flatten[id];
+    if (item.schema[propName] !== undefined) return item.schema[propName];
+    if (item && item.parent) {
+      var parentSchema = flatten[item.parent].schema;
+      if (parentSchema[propName] !== undefined) {
+        return parentSchema[propName];
+      } else {
+        return getParentProps(propName, item.parent, flatten);
+      }
+    }
+  } catch (error) {
+    return undefined;
+  }
+};
+export function looseJsonParse(obj) {
+  return Function('"use strict";return (' + obj + ')')();
+}
+
+// 获得 propsSchema 的 children
+export function getChildren2(schema) {
+  if (!schema) return [];
+  var properties = schema.properties,
+    items = schema.items,
+    type = schema.type;
+  if (!properties && !items) {
+    return [];
+  }
+  var schemaSubs = {};
+  if (type === 'object') {
+    schemaSubs = properties;
+  }
+  if (type === 'array') {
+    schemaSubs = items.properties;
+  }
+  return Object.keys(schemaSubs).map(function (name) {
+    return {
+      schema: schemaSubs[name],
+      name: name
+    };
+  });
+}
+
+// 解析函数字符串值
+// getDataById(formData, '#/a/b/c')
+export function getDataById(object, path) {
+  var parts = castPath(path, object);
+  var current = object;
+  var index = 0;
+  var length = parts.length;
+  while (current !== null && current !== undefined && index < length) {
+    var key = toKey(parts[index++]);
+    if (Array.isArray(current) && _typeof(current[0]) === 'object') {
+      current = key ? current[0][key] : current;
+    } else {
+      current = key ? current[key] : current;
+    }
+  }
+  return index && index === length ? current : undefined;
+}
+function castPath(value, object) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : value.match(/([^./[\]#"']+)/g);
+}
+function toKey(value) {
+  if (typeof value === 'string') {
+    return value.replace(/^#\/?/, '');
+  }
+  var result = "".concat(value);
+  return result === '0' && 1 / value === -Infinity ? '-0' : result;
+}
+var reIsDeepProp = /#\/.+\//;
+var reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (Array.isArray(value)) {
+    return false;
+  }
+  var type = _typeof(value);
+  if (type === 'number' || type === 'boolean' || value === null || value === undefined) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object !== null && object !== undefined && value in Object(object);
+}
+export var oldSchemaToNew = function oldSchemaToNew(schema) {
+  if (schema && schema.propsSchema) {
+    var propsSchema = schema.propsSchema,
+      rest = _objectWithoutProperties(schema, _excluded);
+    return _objectSpread({
+      schema: propsSchema
+    }, rest);
+  }
+  if (schema && schema.schema) {
+    return schema.schema;
+  }
+  if (schema && schema.type === 'object') {
+    return schema;
+  }
+  return _objectSpread({
+    type: 'object',
+    properties: {}
+  }, schema);
+};
+export var newSchemaToOld = function newSchemaToOld(setting) {
+  if (setting && setting.schema) {
+    var schema = setting.schema,
+      rest = _objectWithoutProperties(setting, _excluded2);
+    return _objectSpread({
+      propsSchema: schema
+    }, rest);
+  }
+  return setting;
+};
+export var schemaToState = function schemaToState(value) {
+  var schema = oldSchemaToNew(value);
+  var frProps = Object.keys(schema).reduce(function (rst, cur) {
+    if (['type', 'properties'].includes(cur)) return rst;
+    return _objectSpread(_objectSpread({}, rst), {}, _defineProperty({}, cur, schema[cur]));
+  }, {});
+  var isNewVersion = !(value && value.propsSchema);
+  return {
+    schema: schema,
+    frProps: frProps,
+    formData: schema.formData || {},
+    isNewVersion: isNewVersion
+  };
+};
+export function defaultGetValueFromEvent(valuePropName) {
+  var event = arguments.length <= 1 ? undefined : arguments[1];
+  if (event && event.target && valuePropName in event.target) {
+    return event.target[valuePropName];
+  }
+  return event;
+}
+export var transformProps = function transformProps(props) {
+  var onChange = props.onChange,
+    value = props.value,
+    defaultValue = props.defaultValue,
+    ownSchema = props.schema,
+    rest = _objectWithoutProperties(props, _excluded3);
+  var schema = _objectSpread({}, ownSchema);
+  var _ref9 = schema || {},
+    trigger = _ref9.trigger,
+    valuePropName = _ref9.valuePropName;
+  var controlProps = {};
+  var _valuePropName = 'value';
+  var _value = value === undefined ? defaultValue : value;
+  if (valuePropName && typeof valuePropName === 'string') {
+    _valuePropName = valuePropName;
+    controlProps[valuePropName] = _value;
+  } else {
+    controlProps.value = _value;
+  }
+  var _onChange = function _onChange() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var newValue = defaultGetValueFromEvent.apply(void 0, [_valuePropName].concat(args));
+    onChange(newValue);
+  };
+  if (trigger && typeof trigger === 'string') {
+    controlProps[trigger] = _onChange;
+  } else {
+    controlProps.onChange = _onChange;
+  }
+
+  // TODO: 之后 ui:xx 会舍去
+  var usefulPropsFromSchema = {
+    disabled: schema.disabled || schema['ui:disabled'],
+    readOnly: schema.readOnly || schema['ui:readonly']
+    // hidden: schema.hidden || schema['ui:hidden'],
+    // $options: schema.options || schema['ui:options'],
+  };
+  var _props = _objectSpread(_objectSpread(_objectSpread({}, controlProps), {}, {
+    schema: schema
+  }, usefulPropsFromSchema), rest);
+  return _props;
+};
+export var mergeInOrder = function mergeInOrder() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+  return args.reduce(function (result, current) {
+    if (!current) return result;
+    return Object.keys(current).reduce(function (rst, key) {
+      if (rst[key]) delete rst[key];
+      return _objectSpread(_objectSpread({}, rst), {}, _defineProperty({}, key, current[key]));
+    }, result);
+  }, {});
+};
+export var defaultGetId = function defaultGetId(name) {
+  return "".concat(name, "_").concat(nanoid(6));
+};