element-ui-for-gov/lib/user-picker.js

element-ui for gov

module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/dist/";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 290);
/******/ })
/************************************************************************/
/******/ ({

/***/ 1:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
/* globals __VUE_SSR_CONTEXT__ */

// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
// This module is a runtime utility for cleaner component module output and will
// be included in the final webpack user bundle.

function normalizeComponent (
  scriptExports,
  render,
  staticRenderFns,
  functionalTemplate,
  injectStyles,
  scopeId,
  moduleIdentifier, /* server only */
  shadowMode /* vue-cli only */
) {
  // Vue.extend constructor export interop
  var options = typeof scriptExports === 'function'
    ? scriptExports.options
    : scriptExports

  // render functions
  if (render) {
    options.render = render
    options.staticRenderFns = staticRenderFns
    options._compiled = true
  }

  // functional template
  if (functionalTemplate) {
    options.functional = true
  }

  // scopedId
  if (scopeId) {
    options._scopeId = 'data-v-' + scopeId
  }

  var hook
  if (moduleIdentifier) { // server build
    hook = function (context) {
      // 2.3 injection
      context =
        context || // cached call
        (this.$vnode && this.$vnode.ssrContext) || // stateful
        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
      // 2.2 with runInNewContext: true
      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
        context = __VUE_SSR_CONTEXT__
      }
      // inject component styles
      if (injectStyles) {
        injectStyles.call(this, context)
      }
      // register component module identifier for async chunk inferrence
      if (context && context._registeredComponents) {
        context._registeredComponents.add(moduleIdentifier)
      }
    }
    // used by ssr in case component is cached and beforeCreate
    // never gets called
    options._ssrRegister = hook
  } else if (injectStyles) {
    hook = shadowMode
      ? function () {
        injectStyles.call(
          this,
          (options.functional ? this.parent : this).$root.$options.shadowRoot
        )
      }
      : injectStyles
  }

  if (hook) {
    if (options.functional) {
      // for template-only hot-reload because in that case the render fn doesn't
      // go through the normalizer
      options._injectStyles = hook
      // register for functional component in vue file
      var originalRender = options.render
      options.render = function renderWithStyleInjection (h, context) {
        hook.call(context)
        return originalRender(h, context)
      }
    } else {
      // inject component registration as beforeCreate hook
      var existing = options.beforeCreate
      options.beforeCreate = existing
        ? [].concat(existing, hook)
        : [hook]
    }
  }

  return {
    exports: scriptExports,
    options: options
  }
}


/***/ }),

/***/ 137:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/tabs");

/***/ }),

/***/ 14:
/***/ (function(module, exports) {

var nestRE = /^(attrs|props|on|nativeOn|class|style|hook)$/

module.exports = function mergeJSXProps (objs) {
  return objs.reduce(function (a, b) {
    var aa, bb, key, nestedKey, temp
    for (key in b) {
      aa = a[key]
      bb = b[key]
      if (aa && nestRE.test(key)) {
        // normalize class
        if (key === 'class') {
          if (typeof aa === 'string') {
            temp = aa
            a[key] = aa = {}
            aa[temp] = true
          }
          if (typeof bb === 'string') {
            temp = bb
            b[key] = bb = {}
            bb[temp] = true
          }
        }
        if (key === 'on' || key === 'nativeOn' || key === 'hook') {
          // merge functions
          for (nestedKey in bb) {
            aa[nestedKey] = mergeFn(aa[nestedKey], bb[nestedKey])
          }
        } else if (Array.isArray(aa)) {
          a[key] = aa.concat(bb)
        } else if (Array.isArray(bb)) {
          a[key] = [aa].concat(bb)
        } else {
          for (nestedKey in bb) {
            aa[nestedKey] = bb[nestedKey]
          }
        }
      } else {
        a[key] = b[key]
      }
    }
    return a
  }, {})
}

function mergeFn (a, b) {
  return function () {
    a && a.apply(this, arguments)
    b && b.apply(this, arguments)
  }
}


/***/ }),

/***/ 290:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXTERNAL MODULE: ./node_modules/babel-helper-vue-jsx-merge-props/index.js
var babel_helper_vue_jsx_merge_props = __webpack_require__(14);
var babel_helper_vue_jsx_merge_props_default = /*#__PURE__*/__webpack_require__.n(babel_helper_vue_jsx_merge_props);

// EXTERNAL MODULE: external "element-ui-for-gov/lib/dialog"
var dialog_ = __webpack_require__(42);
var dialog_default = /*#__PURE__*/__webpack_require__.n(dialog_);

// EXTERNAL MODULE: external "element-ui-for-gov/lib/tabs"
var tabs_ = __webpack_require__(137);
var tabs_default = /*#__PURE__*/__webpack_require__.n(tabs_);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/tabs/src/tab-pane.vue?vue&type=template&id=9145a070&
var tab_panevue_type_template_id_9145a070_render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return !_vm.lazy || _vm.loaded || _vm.active
    ? _c(
        "div",
        {
          directives: [
            {
              name: "show",
              rawName: "v-show",
              value: _vm.active,
              expression: "active"
            }
          ],
          staticClass: "el-tab-pane",
          attrs: {
            role: "tabpanel",
            "aria-hidden": !_vm.active,
            id: "pane-" + _vm.paneName,
            "aria-labelledby": "tab-" + _vm.paneName
          }
        },
        [_vm._t("default")],
        2
      )
    : _vm._e()
}
var staticRenderFns = []
tab_panevue_type_template_id_9145a070_render._withStripped = true


// CONCATENATED MODULE: ./packages/tabs/src/tab-pane.vue?vue&type=template&id=9145a070&

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/tabs/src/tab-pane.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//

/* harmony default export */ var tab_panevue_type_script_lang_js_ = ({
  name: 'ElTabPane',

  componentName: 'ElTabPane',

  props: {
    label: String,
    labelContent: Function,
    name: String,
    closable: Boolean,
    disabled: Boolean,
    lazy: Boolean
  },

  data: function data() {
    return {
      index: null,
      loaded: false
    };
  },


  computed: {
    isClosable: function isClosable() {
      return this.closable || this.$parent.closable;
    },
    active: function active() {
      var active = this.$parent.currentName === (this.name || this.index);
      if (active) {
        this.loaded = true;
      }
      return active;
    },
    paneName: function paneName() {
      return this.name || this.index;
    }
  },

  updated: function updated() {
    this.$parent.$emit('tab-nav-update');
  }
});
// CONCATENATED MODULE: ./packages/tabs/src/tab-pane.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_tab_panevue_type_script_lang_js_ = (tab_panevue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(1);

// CONCATENATED MODULE: ./packages/tabs/src/tab-pane.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_tab_panevue_type_script_lang_js_,
  tab_panevue_type_template_id_9145a070_render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/tabs/src/tab-pane.vue"
/* harmony default export */ var tab_pane = (component.exports);
// EXTERNAL MODULE: external "element-ui-for-gov/lib/button"
var button_ = __webpack_require__(9);
var button_default = /*#__PURE__*/__webpack_require__.n(button_);

// EXTERNAL MODULE: external "element-ui-for-gov/lib/message"
var message_ = __webpack_require__(80);
var message_default = /*#__PURE__*/__webpack_require__.n(message_);

// EXTERNAL MODULE: external "element-ui-for-gov/lib/row"
var row_ = __webpack_require__(43);
var row_default = /*#__PURE__*/__webpack_require__.n(row_);

// EXTERNAL MODULE: external "element-ui-for-gov/lib/col"
var col_ = __webpack_require__(36);
var col_default = /*#__PURE__*/__webpack_require__.n(col_);

// EXTERNAL MODULE: external "element-ui-for-gov/lib/tree"
var tree_ = __webpack_require__(31);
var tree_default = /*#__PURE__*/__webpack_require__.n(tree_);

// EXTERNAL MODULE: external "element-ui-for-gov/lib/utils/tree-store"
var tree_store_ = __webpack_require__(82);
var tree_store_default = /*#__PURE__*/__webpack_require__.n(tree_store_);

// CONCATENATED MODULE: ./packages/user-picker/src/section-header.js
var prefix = 'el-user-picker';

/* harmony default export */ var section_header = ({
  name: 'SectionHeader',
  props: {
    title: {
      type: String
    }
  },
  render: function render() {
    var h = arguments[0];
    var title = this.title,
        $slots = this.$slots;

    return h(
      'div',
      { 'class': prefix + '__section-header' },
      [title, h(
        'span',
        { 'class': 'right' },
        [$slots.right]
      )]
    );
  }
});
// EXTERNAL MODULE: external "element-ui-for-gov/lib/input"
var input_ = __webpack_require__(8);
var input_default = /*#__PURE__*/__webpack_require__.n(input_);

// CONCATENATED MODULE: ./packages/user-picker/src/selected-list.js






var selected_list_prefix = 'el-user-picker';
/* harmony default export */ var selected_list = ({
  name: 'SelectedList',
  props: {
    label: String,
    checkedUsers: Array
  },
  components: { ElButton: button_default.a, ElInput: input_default.a, SectionHeader: section_header },
  data: function data() {
    return {
      keyword: ''
    };
  },

  methods: {
    uncheckedUser: function uncheckedUser(user) {
      var index = this.checkedUsers.findIndex(function (item) {
        return item === user;
      });
      this.checkedUsers.splice(index, 1);
      this.$emit('unchecked-user');
    }
  },

  render: function render() {
    var _this = this;

    var h = arguments[0];
    var checkedUsers = this.checkedUsers,
        label = this.label;

    var filteredUsers = checkedUsers.filter(function (item) {
      return _this.keyword ? item[label].indexOf(_this.keyword) > -1 : true;
    });
    return h(
      'div',
      { 'class': selected_list_prefix + '__section-wrapper' },
      [h(section_header, {
        attrs: { title: '\u5DF2\u9009\u5217\u8868' }
      }), h(
        'div',
        { 'class': 'filter-wrapper' },
        [h(input_default.a, babel_helper_vue_jsx_merge_props_default()([{
          attrs: { value: this.keyword
          }
        }, {
          on: {
            input: function input(value) {
              _this.keyword = value;
            }
          }
        }, {
          attrs: { prefixIcon: 'sg-icon sg-icon-fangdajing', placeholder: '\u8BF7\u8F93\u5165\u5173\u952E\u8BCD' }
        }]))]
      ), h(
        'div',
        { 'class': selected_list_prefix + '__section-content' },
        [h(
          'ul',
          { 'class': selected_list_prefix + '__section-list' },
          [filteredUsers.map(function (item) {
            return h('li', [item[label], h('i', babel_helper_vue_jsx_merge_props_default()([{ 'class': 'el-icon-close' }, { on: { click: _this.uncheckedUser.bind(_this, item) } }]))]);
          })]
        )]
      )]
    );
  }
});
// CONCATENATED MODULE: ./packages/user-picker/src/transfer.js


var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };










var transfer_prefix = 'el-user-picker';
/* harmony default export */ var transfer = ({
  name: 'Transfer',
  inject: ['handleChangeUser', 'clearChecked', 'nodeKey', 'setTreeInstance'],
  props: {
    treeProps: Object,
    fieldNames: Object,
    grid: Object,
    checkedUsers: Array,
    filterNodeMethod: Function,
    defaultChecked: Array
  },
  components: { ElRow: row_default.a, ElCol: col_default.a, ElButton: button_default.a, ElTree: tree_default.a, SectionHeader: section_header, SelectedList: selected_list },
  data: function data() {
    return {
      treeData: [],
      store: null,
      totalData: [],
      prevChecked: []
    };
  },
  created: function created() {
    var _this = this;

    var _treeProps = this.treeProps,
        lazy = _treeProps.lazy,
        loadData = _treeProps.loadData,
        children = _treeProps.children,
        disabled = _treeProps.disabled;
    var fieldNames = this.fieldNames;

    this.store = new tree_store_default.a({
      key: this.nodeKey,
      label: function label(data) {
        return data[fieldNames.parent] || data[fieldNames.userName];
      },
      isLeaf: function isLeaf(data) {
        return !!data[fieldNames.userName];
      },
      children: children || 'children',
      disabled: disabled || 'disabled',
      data: []
    });
    !lazy ? loadData().then(function (data) {
      _this.store.initData(data);
      _this.treeData = _this.store.data;
      _this.totalData = _this.treeData;
      _this.setDefaultChecked(_this.defaultChecked);
    }) : this.setDefaultChecked(this.defaultChecked);
  },
  mounted: function mounted() {
    this.setTreeInstance(this.treeProps.key, this);
  },


  watch: {
    defaultChecked: function defaultChecked(users) {
      var _this2 = this;

      this.$nextTick(function () {
        _this2.setDefaultChecked(users);
      });
    },
    checkedUsers: function checkedUsers(arr) {
      var _this3 = this;

      var nodes = [];
      arr.forEach(function (item) {
        var cache = _this3.store.getNodes(item);
        nodes = nodes.concat(cache);
      });
      this.prevChecked = [].concat(nodes);
      // console.log('selected nodes: ', nodes);
      this.$nextTick(function () {
        _this3.setCheckedNodes(nodes);
      });
    }
  },
  methods: {
    setDefaultChecked: function setDefaultChecked(keys) {
      var _this4 = this;

      // console.log(ids);
      var users = [];
      keys.forEach(function (user) {
        // console.log(user);
        var nodes = (typeof user === 'undefined' ? 'undefined' : _typeof(user)) === 'object' ? [{ data: user }] : _this4.store.getNodesByKey(user);
        if (nodes.length) {
          users.push(nodes[0].data);
        }
      });
      this.handleChangeUser(users);
    },
    handleCheck: function handleCheck(node, _ref) {
      var checkedNodes = _ref.checkedNodes;

      // console.log(this.prevChecked, checkedNodes);
      var deleteArr = this.store.difference(this.prevChecked, checkedNodes.filter(function (node) {
        return node.isLeaf;
      }));
      // console.log(deleteArr);
      var users = checkedNodes.filter(function (node) {
        return node.isLeaf;
      }).map(function (item) {
        return item.data;
      });
      var deleteUsers = deleteArr.filter(function (node) {
        return node.isLeaf;
      }).map(function (item) {
        return item.data;
      });
      this.handleChangeUser(users, deleteUsers);
    },
    getCheckedNodes: function getCheckedNodes() {
      var nodes = this.$refs['tree'].getCheckedNodes();
      var users = nodes.filter(function (node) {
        return node.isLeaf;
      }).map(function (item) {
        return item.data;
      });
      this.handleChangeUser(users, []);
    },
    checkAll: function checkAll() {
      var _this5 = this;

      // console.log('checkAll');
      var checkAllMethod = this.treeProps.checkAllMethod;

      if (checkAllMethod) {
        checkAllMethod(this, function (users) {
          _this5.handleChangeUser(users);
        });
      } else {
        var users = [];
        var traverse = function traverse(arr) {
          arr.forEach(function (item) {
            if (item.isLeaf && !item.disabled) {
              users.push(item.data);
            } else if (item.children) {
              traverse(item.children);
            }
          });
        };
        traverse(this.totalData);
        this.handleChangeUser(users);
      }
    },
    setCheckedNodes: function setCheckedNodes(nodes) {
      this.$refs['tree'].setCheckedNodes(nodes);
    },
    filter: function filter(value) {
      this.$refs['tree'].filter(value);
    },
    setTreeData: function setTreeData(data) {
      this.store.initData(data, this.treeProps.lazy);
      this.treeData = this.store.data;
      this.setDefaultChecked(this.defaultChecked);
    },
    loadDataAsync: function loadDataAsync(node, resolve, isCheck) {
      var _this6 = this;

      var loadDataAsync = this.treeProps.loadDataAsync;
      // console.log('load', node);

      loadDataAsync(node.data ? node.data : node, function (data) {
        if (data && data.length > 0) {
          var childList = data.map(function (item) {
            return _this6.store.registerNode(item);
          });
          _this6.totalData = _this6.totalData.concat(childList);
          if (!isCheck) {
            _this6.setDefaultChecked(_this6.defaultChecked);
          } else {
            var selectList = childList.filter(function (node) {
              return !node.disabled && node.isLeaf;
            }).map(function (node) {
              return node.key;
            });
            _this6.defaultChecked.forEach(function (item) {
              if (!selectList.includes(item)) {
                selectList.push(item);
              }
            });
            _this6.setDefaultChecked(selectList);
          }
          return resolve(childList);
        } else {
          return resolve([]);
        }
      });
    }
  },

  render: function render() {
    var h = arguments[0];
    var treeData = this.treeData,
        fieldNames = this.fieldNames,
        treeProps = this.treeProps,
        checkedUsers = this.checkedUsers,
        $slots = this.$slots;

    return h(row_default.a, [h(
      col_default.a,
      {
        attrs: { span: 10 }
      },
      [h(
        'div',
        { 'class': transfer_prefix + '__section-wrapper' },
        [h(section_header, {
          attrs: { title: '\u5F85\u9009\u5217\u8868' }
        }), $slots.filter && h(
          'div',
          { 'class': 'filter-wrapper' },
          [$slots.filter]
        ), h(
          'div',
          { 'class': transfer_prefix + '__section-content' },
          [h(tree_default.a, babel_helper_vue_jsx_merge_props_default()([{ ref: 'tree',
            attrs: { lazy: treeProps.lazy,
              data: treeData,
              nodeKey: 'id',
              load: this.loadDataAsync,
              props: {
                isLeaf: function isLeaf(item) {
                  return item.isLeaf;
                }
              },
              'show-checkbox': true,
              'expand-on-check': treeProps.lazy,
              filterNodeMethod: this.filterNodeMethod
            }
          }, {
            on: {
              // 'check-change': treeProps.lazy ? this.handleCheckChange : this.getCheckedNodes,
              'node-expand': treeProps.lazy ? this.getCheckedNodes : function () {},
              'check': this.handleCheck
            }
          }]))]
        )]
      )]
    ), h(
      col_default.a,
      {
        attrs: { span: 4 },
        'class': transfer_prefix + '__section-btns' },
      [h(
        button_default.a,
        { on: { click: this.checkAll } },
        ['\u5168\u9009', h('i', { 'class': 'el-icon-arrow-right' })]
      ), h('br'), h(
        button_default.a,
        { on: { click: this.clearChecked } },
        ['\u6E05\u7A7A\u5DF2\u9009']
      )]
    ), h(
      col_default.a,
      {
        attrs: { span: 10 }
      },
      [h(selected_list, {
        attrs: { checkedUsers: checkedUsers, label: fieldNames.userName }
      })]
    )]);
  }
});
// CONCATENATED MODULE: ./packages/user-picker/src/picker-panel.js


/* harmony default export */ var picker_panel = ({
  name: 'PickerPanel',
  components: { Transfer: transfer },
  props: {
    defaultChecked: Array,
    treeProps: Object,
    checkedUsers: Array
  },

  render: function render() {
    var h = arguments[0];
    var _treeProps = this.treeProps,
        parentName = _treeProps.parentName,
        userName = _treeProps.userName,
        renderFilter = _treeProps.renderFilter,
        filterNodeMethod = _treeProps.filterNodeMethod;

    return h(
      transfer,
      { ref: 'tree',
        attrs: { fieldNames: {
            parent: parentName,
            userName: userName
          },
          treeProps: this.treeProps,
          filterNodeMethod: filterNodeMethod,
          defaultChecked: this.defaultChecked,
          checkedUsers: this.checkedUsers
        }
      },
      [h(
        'template',
        { slot: 'filter' },
        [renderFilter && renderFilter(this.$refs['tree'])]
      )]
    );
  }
});
// CONCATENATED MODULE: ./packages/user-picker/src/user-picker.js









/* harmony default export */ var user_picker = ({
  name: 'UserPicker',
  components: { ElDialog: dialog_default.a, ElTabs: tabs_default.a, ElTabPane: tab_pane, ElButton: button_default.a, PickerPanel: picker_panel },
  props: {
    title: {
      type: String,
      default: '选择人员'
    },
    visible: {
      type: Boolean
    },
    required: {
      type: Boolean,
      default: true
    },

    requiredTips: {
      type: String,
      default: '请选择人员'
    },

    userUniqueId: { type: String, default: 'id' },

    defaultChecked: {
      type: Array,
      default: function _default() {
        return [];
      }
    },

    tabs: {
      type: Array,
      default: function _default() {
        return [];
      }
    },

    confirmText: {
      type: String,
      default: '确定'
    },

    cancelText: {
      type: String,
      default: '取消'
    }
  },

  data: function data() {
    return {
      checkedUsers: [],
      defaultCheckUsers: [],
      treeInstances: {}
    };
  },
  provide: function provide() {
    return {
      handleChangeUser: this.handleChangeUser,
      clearChecked: this.clearChecked,
      nodeKey: this.userUniqueId,
      setTreeInstance: this.setTreeInstance
    };
  },


  watch: {
    visible: {
      handler: function handler(val) {
        if (val) {
          this.defaultCheckUsers = this.defaultChecked.slice();
        }
      },

      immediate: true
    }
  },

  methods: {
    getTreeInstance: function getTreeInstance() {
      return this.treeInstances;
    },
    setTreeInstance: function setTreeInstance(key, $tree) {
      this.treeInstances[key] = $tree;
      this.$emit('mounted-tree', { key: key, $tree: $tree });
    },
    handleChangeUser: function handleChangeUser(users) {
      var _this = this;

      var deleteUsers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

      var arr = [];
      var unique = {};
      this.checkedUsers.concat(users).forEach(function (user) {
        var del = deleteUsers.find(function (del) {
          return del[_this.userUniqueId] === user[_this.userUniqueId];
        });
        if (!unique[user[_this.userUniqueId]] && !del) {
          arr.push(user);
          unique[user[_this.userUniqueId]] = user;
        }
      });
      this.checkedUsers = arr;
    },
    clearChecked: function clearChecked() {
      this.checkedUsers = [];
    },
    handleCancel: function handleCancel(e) {
      this.checkedUsers = [];
      this.$emit('cancel');
    },
    handleConfirm: function handleConfirm() {
      if (this.required && this.checkedUsers.length === 0) {
        message_default.a.error(this.requiredTips);
        return;
      }
      this.$emit('confirm', this.checkedUsers.slice(0));
      this.checkedUsers = [];
    }
  },

  render: function render() {
    var h = arguments[0];
    var title = this.title,
        visible = this.visible,
        checkedUsers = this.checkedUsers,
        defaultCheckUsers = this.defaultCheckUsers,
        tabs = this.tabs,
        confirmText = this.confirmText,
        cancelText = this.cancelText;


    return h(
      dialog_default.a,
      babel_helper_vue_jsx_merge_props_default()([{
        attrs: {
          'append-to-body': true,
          'close-on-click-modal': false,
          title: title,
          visible: visible
        }
      }, { on: { 'update:visible': this.handleCancel } }, {
        attrs: {
          width: '1000px' }
      }]),
      [h(
        'div',
        { 'class': 'el-user-picker' },
        [tabs.length > 1 && h(tabs_default.a, [tabs.map(function (tab) {
          return h(
            tab_pane,
            { key: tab.key, attrs: { label: tab.title }
            },
            [h(picker_panel, {
              attrs: { defaultChecked: defaultCheckUsers, checkedUsers: checkedUsers, treeProps: tab }
            })]
          );
        })]), tabs.length === 1 && h(picker_panel, {
          attrs: { defaultChecked: defaultCheckUsers, checkedUsers: checkedUsers, treeProps: tabs[0] }
        })]
      ), h(
        'span',
        { 'class': 'dialog-footer', slot: 'footer' },
        [h(
          button_default.a,
          {
            on: {
              click: this.handleCancel
            }
          },
          [cancelText]
        ), h(
          button_default.a,
          babel_helper_vue_jsx_merge_props_default()([{
            attrs: { type: 'primary' }
          }, {
            on: {
              click: this.handleConfirm
            }
          }]),
          [confirmText]
        )]
      )]
    );
  }
});
// CONCATENATED MODULE: ./packages/user-picker/index.js


/* istanbul ignore next */
user_picker.install = function (Vue) {
  Vue.component(user_picker.name, user_picker);
};

/* harmony default export */ var packages_user_picker = __webpack_exports__["default"] = (user_picker);

/***/ }),

/***/ 31:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/tree");

/***/ }),

/***/ 36:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/col");

/***/ }),

/***/ 42:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/dialog");

/***/ }),

/***/ 43:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/row");

/***/ }),

/***/ 8:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/input");

/***/ }),

/***/ 80:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/message");

/***/ }),

/***/ 82:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/utils/tree-store");

/***/ }),

/***/ 9:
/***/ (function(module, exports) {

module.exports = require("element-ui-for-gov/lib/button");

/***/ })

/******/ });