formiojs-eorion 0.0.9 → 0.1.1

package/Formio.js

@@ -1724,7 +1724,7 @@ Formio.projectUrlSet = false;
 Formio.plugins = [];
 Formio.cache = {};
 Formio.Providers = _providers.default;
-Formio.version = '0.0.9';
+Formio.version = '0.1.1';
 Formio.pathType = '';
 Formio.events = new _EventEmitter.default();
 Formio.cdn = new _CDN.default();

package/components/CustomTabs/Tabs.form.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+require("core-js/modules/es.array.concat.js");
+var _NestedComponent = _interopRequireDefault(require("../_classes/nested/NestedComponent.form"));
+var _TabsEdit = _interopRequireDefault(require("./editForm/Tabs.edit.display"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _default() {
+  for (var _len = arguments.length, extend = new Array(_len), _key = 0; _key < _len; _key++) {
+    extend[_key] = arguments[_key];
+  }
+  return _NestedComponent.default.apply(void 0, [[{
+    key: 'display',
+    components: _TabsEdit.default
+  }, {
+    key: 'addons',
+    ignore: true
+  }]].concat(extend));
+}

package/components/CustomTabs/Tabs.js

@@ -0,0 +1,355 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+require("core-js/modules/es.reflect.get.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.symbol.to-primitive.js");
+require("core-js/modules/es.date.to-primitive.js");
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.number.constructor.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.regexp.exec.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.array.find-index.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.object.get-prototype-of.js");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _NestedComponent2 = _interopRequireDefault(require("../_classes/nested/NestedComponent"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var CustomTabsComponent = /*#__PURE__*/function (_NestedComponent) {
+  _inherits(CustomTabsComponent, _NestedComponent);
+  var _super = _createSuper(CustomTabsComponent);
+  function CustomTabsComponent() {
+    var _this;
+    _classCallCheck(this, CustomTabsComponent);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.currentTab = 0;
+    _this.noField = true;
+    return _this;
+  }
+  _createClass(CustomTabsComponent, [{
+    key: "defaultSchema",
+    get: function get() {
+      return CustomTabsComponent.schema();
+    }
+  }, {
+    key: "schema",
+    get: function get() {
+      var _this2 = this;
+      var schema = _get(_getPrototypeOf(CustomTabsComponent.prototype), "schema", this);
+      // We need to clone this because the builder uses the "components" reference and this would reset that reference.
+      var components = _lodash.default.cloneDeep(this.component.components);
+      schema.components = components.map(function (tab, index) {
+        tab.components = _this2.tabs[index].map(function (component) {
+          return component.schema;
+        });
+        return tab;
+      });
+      return schema;
+    }
+  }, {
+    key: "tabKey",
+    get: function get() {
+      return "tab-".concat(this.key);
+    }
+  }, {
+    key: "tabLikey",
+    get: function get() {
+      return "tabLi-".concat(this.key);
+    }
+  }, {
+    key: "tabLinkKey",
+    get: function get() {
+      return "tabLink-".concat(this.key);
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      var _this3 = this;
+      this.components = [];
+      this.tabs = [];
+      _lodash.default.each(this.component.components, function (tab, index) {
+        _this3.tabs[index] = [];
+        // Initialize empty tabs.
+        tab.components = tab.components || [];
+        _lodash.default.each(tab.components, function (comp) {
+          var component = _this3.createComponent(comp);
+          component.tab = index;
+          _this3.tabs[index].push(component);
+        });
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this4 = this;
+      return _get(_getPrototypeOf(CustomTabsComponent.prototype), "render", this).call(this, this.renderTemplate('customTab', {
+        tabKey: this.tabKey,
+        tabLikey: this.tabLikey,
+        tabLinkKey: this.tabLinkKey,
+        currentTab: this.currentTab,
+        tabComponents: this.tabs.map(function (tab) {
+          return _this4.renderComponents(tab);
+        })
+      }, this.options.flatten || this.options.pdf ? 'flat' : null));
+    }
+  }, {
+    key: "attach",
+    value: function attach(element) {
+      var _this$loadRefs,
+        _this5 = this;
+      this.loadRefs(element, (_this$loadRefs = {}, _defineProperty(_this$loadRefs, this.tabLinkKey, 'multiple'), _defineProperty(_this$loadRefs, this.tabKey, 'multiple'), _defineProperty(_this$loadRefs, this.tabLikey, 'multiple'), _defineProperty(_this$loadRefs, 'tabLine', 'single'), _this$loadRefs));
+      ['change', 'error'].forEach(function (event) {
+        return _this5.on(event, _this5.handleTabsValidation.bind(_this5));
+      });
+      var superAttach = _get(_getPrototypeOf(CustomTabsComponent.prototype), "attach", this).call(this, element);
+      this.refs[this.tabLinkKey].forEach(function (tabLink, index) {
+        _this5.addEventListener(tabLink, 'click', function (event) {
+          event.preventDefault();
+          _this5.setTab(index);
+        });
+        _this5.addEventListener(tabLink, 'mouseover', function (event) {
+          tabLink.style.color = _this5.component["headerHoverColor"];
+        });
+        _this5.addEventListener(tabLink, 'mouseout', function (event) {
+          if (index === _this5.currentTab) {
+            tabLink.style.color = _this5.component["headerColor"];
+          } else {
+            tabLink.style.color = _this5.component["headerNormalColor"];
+          }
+        });
+      });
+      this.refs[this.tabKey].forEach(function (tab, index) {
+        _this5.attachComponents(tab, _this5.tabs[index], _this5.component.components[index].components);
+      });
+      this.setTabLine();
+      return superAttach;
+    }
+  }, {
+    key: "detach",
+    value: function detach(all) {
+      _get(_getPrototypeOf(CustomTabsComponent.prototype), "detach", this).call(this, all);
+    }
+
+    /**
+     * 通过childKey来设置tab选中
+     * @param childKey
+     */
+  }, {
+    key: "setTabByKey",
+    value: function setTabByKey(childKey) {
+      var _this6 = this;
+      _lodash.default.each(this.component.components, function (tab, index) {
+        if (tab.key === childKey) {
+          _this6.setTab(index);
+        }
+      });
+    }
+  }, {
+    key: "setTabLine",
+    value: function setTabLine() {
+      var _this7 = this;
+      _lodash.default.each(this.refs[this.tabLinkKey], function (tabLink, tabIndex) {
+        // 设置下划线位置 //设置颜色
+        if (tabIndex === _this7.currentTab) {
+          _this7.refs.tabLine.style.width = "".concat(tabLink.offsetWidth, "px");
+          // 10是容器的padding
+          _this7.refs.tabLine.style.transform = "translateX(".concat(tabLink.offsetLeft - 15, "px)");
+          tabLink.style.color = _this7.component["headerColor"];
+        } else {
+          tabLink.style.color = _this7.component["headerNormalColor"];
+        }
+      });
+    }
+
+    /**
+     * Set the current tab.
+     *
+     * @param index
+     */
+  }, {
+    key: "setTab",
+    value: function setTab(index) {
+      var _this8 = this;
+      if (!this.tabs || !this.tabs[index] || !this.refs[this.tabKey] || !this.refs[this.tabKey][index]) {
+        return;
+      }
+      this.currentTab = index;
+      _lodash.default.each(this.refs[this.tabKey], function (tab) {
+        _this8.removeClass(tab, 'formio-tab-panel-active');
+        tab.style.display = 'none';
+      });
+      this.addClass(this.refs[this.tabKey][index], 'formio-tab-panel-active');
+      this.refs[this.tabKey][index].style.display = 'block';
+      _lodash.default.each(this.refs[this.tabLinkKey], function (tabLink, tabIndex) {
+        if (_this8.refs[_this8.tabLinkKey][tabIndex]) {
+          _this8.removeClass(tabLink, 'formio-tab-link-active');
+        }
+        if (_this8.refs[_this8.tabLikey][tabIndex]) {
+          _this8.removeClass(_this8.refs[_this8.tabLikey][tabIndex], 'formio-tab-link-container-active');
+        }
+      });
+      if (this.refs[this.tabLikey][index]) {
+        this.addClass(this.refs[this.tabLikey][index], 'formio-tab-link-container-active');
+      }
+      if (this.refs[this.tabLinkKey][index]) {
+        this.addClass(this.refs[this.tabLinkKey][index], 'formio-tab-link-active');
+      }
+      this.setTabLine();
+      this.triggerChange();
+    }
+  }, {
+    key: "beforeFocus",
+    value: function beforeFocus(component) {
+      if ('beforeFocus' in this.parent) {
+        this.parent.beforeFocus(this);
+      }
+      var tabIndex = this.tabs.findIndex(function (tab) {
+        return tab.some(function (comp) {
+          return comp === component;
+        });
+      });
+      if (tabIndex !== -1 && this.currentTab !== tabIndex) {
+        this.setTab(tabIndex);
+      }
+    }
+  }, {
+    key: "setErrorClasses",
+    value: function setErrorClasses(elements, dirty, hasErrors, hasMessages) {
+      var _this9 = this;
+      var element = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : this.element;
+      if (this.component.modalEdit) {
+        _get(_getPrototypeOf(CustomTabsComponent.prototype), "setErrorClasses", this).call(this, elements, dirty, hasErrors, hasMessages, element);
+      }
+      elements.forEach(function (element) {
+        _this9.addClass(element, 'is-invalid');
+        if (element.getAttribute('ref') !== 'openModal') {
+          if (_this9.options.highlightErrors) {
+            _this9.addClass(element, 'tab-error');
+          } else {
+            _this9.addClass(element, 'has-error');
+          }
+        }
+      });
+    }
+  }, {
+    key: "clearErrorClasses",
+    value: function clearErrorClasses(elements) {
+      var _this10 = this;
+      if (this.options.server || !this.rendered) {
+        return;
+      }
+      if (this.component.modalEdit) {
+        var element = Array.isArray(elements) || elements instanceof NodeList ? this.element : elements;
+        _get(_getPrototypeOf(CustomTabsComponent.prototype), "clearErrorClasses", this).call(this, element);
+      }
+      elements = Array.isArray(elements) || elements instanceof NodeList ? elements : [elements];
+      elements.forEach(function (element) {
+        _this10.removeClass(element, 'is-invalid');
+        _this10.removeClass(element, 'tab-error');
+        _this10.removeClass(element, 'has-error');
+      });
+    }
+  }, {
+    key: "handleTabsValidation",
+    value: function handleTabsValidation() {
+      if (!this.refs[this.tabLinkKey] || !this.refs[this.tabLinkKey].length || !this.tabs.length) {
+        return;
+      }
+      // 切换tab时，刷新taskCalendar组件，修复taskCalendar在tab中高度错乱的问题
+      if (this.tabs[this.currentTab] && this.tabs[this.currentTab].length > 0 && this.tabs[this.currentTab][0].type === 'taskCalendar') {
+        this.tabs[this.currentTab][0].refresh(new Date().getTime());
+      }
+      this.clearErrorClasses(this.refs[this.tabLinkKey]);
+      var invalidTabsIndexes = this.tabs.reduce(function (invalidTabs, tab, tabIndex) {
+        var hasComponentWithError = tab.some(function (comp) {
+          return !!comp.error;
+        });
+        return hasComponentWithError ? [].concat(_toConsumableArray(invalidTabs), [tabIndex]) : invalidTabs;
+      }, []);
+      if (!invalidTabsIndexes.length) {
+        return;
+      }
+      var invalidTabs = _toConsumableArray(this.refs[this.tabLinkKey]).filter(function (_, tabIndex) {
+        return invalidTabsIndexes.includes(tabIndex);
+      });
+      this.setErrorClasses(invalidTabs);
+    }
+  }], [{
+    key: "schema",
+    value: function schema() {
+      for (var _len2 = arguments.length, extend = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        extend[_key2] = arguments[_key2];
+      }
+      return _NestedComponent2.default.schema.apply(_NestedComponent2.default, [{
+        label: 'CustomTabs',
+        type: 'customTabs',
+        input: false,
+        key: 'custom_tabs',
+        persistent: false,
+        tableView: false,
+        components: [{
+          label: 'Tab 1',
+          key: 'tab1',
+          components: []
+        }],
+        verticalLayout: false
+      }].concat(extend));
+    }
+  }, {
+    key: "builderInfo",
+    get: function get() {
+      return {
+        title: 'CustomTabs',
+        group: 'layout',
+        icon: 'folder-o',
+        weight: 50,
+        documentation: '/userguide/forms/layout-components#custom-tabs',
+        schema: CustomTabsComponent.schema()
+      };
+    }
+  }]);
+  return CustomTabsComponent;
+}(_NestedComponent2.default);
+exports.default = CustomTabsComponent;

package/components/CustomTabs/Tabs.unit.js

@@ -0,0 +1,43 @@
+"use strict";
+
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+var _powerAssert = _interopRequireDefault(require("power-assert"));
+var _Formio = _interopRequireDefault(require("../../Formio"));
+var _fixtures = require("./fixtures");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('Tabs Component', function () {
+  it('Test setting error classes when set to modalEdit', function (done) {
+    var formElement = document.createElement('div');
+    _Formio.default.createForm(formElement, {
+      display: 'form',
+      type: 'form',
+      components: [_fixtures.comp1]
+    }).then(function (form) {
+      var comp = form.components[0];
+      var data = {
+        textField: ''
+      };
+      form.checkValidity(data, true, data);
+      setTimeout(function () {
+        var openModalWrapper = form.element.querySelector('[ref="openModalWrapper"]');
+        (0, _powerAssert.default)(openModalWrapper.className.includes('formio-error-wrapper'), 'Should have error class');
+        (0, _powerAssert.default)(openModalWrapper.className.includes('has-message'), 'Should have class indicating that the component has a message');
+        var openModalButton = comp.element.querySelector('[ref="openModal"]');
+        (0, _powerAssert.default)(!openModalButton.className.includes('tab-error'), 'Open modal element should not have a tab-error class');
+        var validData = {
+          textField: 'Text'
+        };
+        form.setSubmission({
+          data: validData
+        });
+        setTimeout(function () {
+          var openModalWrapper = form.element.querySelector('[ref="openModalWrapper"]');
+          (0, _powerAssert.default)(!openModalWrapper.className.includes('formio-error-wrapper'), 'Should not have error class');
+          (0, _powerAssert.default)(!openModalWrapper.className.includes('has-message'), 'Should not have class indicating that the component has a message');
+          done();
+        }, 250);
+      }, 200);
+    }).catch(done);
+  });
+});

package/components/CustomTabs/editForm/Tabs.edit.display.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = [{
+  key: 'labelPosition',
+  ignore: true
+}, {
+  key: 'placeholder',
+  ignore: true
+}, {
+  key: 'description',
+  ignore: true
+}, {
+  key: 'autofocus',
+  ignore: true
+}, {
+  key: 'tooltip',
+  ignore: true
+}, {
+  key: 'tabindex',
+  ignore: true
+}, {
+  key: 'disabled',
+  ignore: true
+}, {
+  key: 'tableView',
+  ignore: true
+}, {
+  key: 'components',
+  type: 'datagrid',
+  input: true,
+  label: 'Tabs',
+  weight: 50,
+  reorder: true,
+  components: [{
+    type: 'textfield',
+    input: true,
+    key: 'label',
+    label: 'Label'
+  }, {
+    type: 'textfield',
+    input: true,
+    key: 'key',
+    label: 'Key',
+    allowCalculateOverride: true,
+    calculateValue: {
+      _camelCase: [{
+        var: 'row.label'
+      }]
+    }
+  }]
+}, {
+  type: 'panel',
+  weight: 51,
+  label: '头部设置',
+  components: [{
+    type: 'checkbox',
+    key: 'hideHeader',
+    label: '隐藏头部',
+    input: true
+  }, {
+    type: 'select',
+    label: '对齐方式',
+    data: {
+      values: [{
+        label: '居中',
+        value: 'center'
+      }, {
+        label: '左对齐',
+        value: 'start'
+      }, {
+        label: '右对齐',
+        value: 'end'
+      }]
+    },
+    key: 'headerAlign',
+    input: true,
+    defaultValue: 'center',
+    dataSrc: 'values'
+  }, {
+    type: 'textfield',
+    key: 'headerBackgroundColor',
+    label: '背景色',
+    defaultValue: 'white',
+    input: true
+  }, {
+    type: 'textfield',
+    key: 'headerColor',
+    tooltip: '文字和下标颜色',
+    label: '主题色',
+    defaultValue: '#333',
+    input: true
+  }, {
+    type: 'textfield',
+    key: 'headerNormalColor',
+    tooltip: '未选中tab颜色',
+    label: '未选中主题色',
+    defaultValue: '#999',
+    input: true
+  }, {
+    type: 'textfield',
+    key: 'headerHoverColor',
+    tooltip: '鼠标经过时颜色',
+    label: 'hover颜色',
+    defaultValue: '#999',
+    input: true
+  }]
+}];
+exports.default = _default;

package/components/CustomTabs/fixtures/comp1.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  label: 'Tabs',
+  components: [{
+    label: 'Tab 1',
+    key: 'tab1',
+    components: []
+  }, {
+    label: 'Tab 2',
+    key: 'tab2',
+    components: [{
+      label: 'Text Field',
+      tableView: true,
+      validate: {
+        required: true
+      },
+      key: 'textField',
+      type: 'textfield',
+      input: true
+    }]
+  }],
+  key: 'tabs',
+  type: 'tabs',
+  input: false,
+  tableView: false,
+  modalEdit: true
+};
+exports.default = _default;

package/components/CustomTabs/fixtures/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "comp1", {
+  enumerable: true,
+  get: function get() {
+    return _comp.default;
+  }
+});
+var _comp = _interopRequireDefault(require("./comp1"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/components/DataChinaGrid/Data.form.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+require("core-js/modules/es.array.concat.js");
+var _NestedComponent = _interopRequireDefault(require("../_classes/nested/NestedComponent.form"));
+var _DataEdit = _interopRequireDefault(require("./editForm/Data.edit.display"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _default() {
+  for (var _len = arguments.length, extend = new Array(_len), _key = 0; _key < _len; _key++) {
+    extend[_key] = arguments[_key];
+  }
+  return _NestedComponent.default.apply(void 0, [[{
+    key: 'display',
+    components: _DataEdit.default
+  }]].concat(extend));
+}