mirror of
https://github.com/mindoc-org/mindoc.git
synced 2025-05-06 22:57:57 +08:00
945 lines
22 KiB
JavaScript
945 lines
22 KiB
JavaScript
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] = {
|
|
/******/ exports: {},
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false
|
|
/******/ };
|
|
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = 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;
|
|
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "/dist/";
|
|
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
module.exports = __webpack_require__(53);
|
|
|
|
|
|
/***/ },
|
|
/* 1 */,
|
|
/* 2 */,
|
|
/* 3 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = function normalizeComponent (
|
|
rawScriptExports,
|
|
compiledTemplate,
|
|
scopeId,
|
|
cssModules
|
|
) {
|
|
var esModule
|
|
var scriptExports = rawScriptExports = rawScriptExports || {}
|
|
|
|
// ES6 modules interop
|
|
var type = typeof rawScriptExports.default
|
|
if (type === 'object' || type === 'function') {
|
|
esModule = rawScriptExports
|
|
scriptExports = rawScriptExports.default
|
|
}
|
|
|
|
// Vue.extend constructor export interop
|
|
var options = typeof scriptExports === 'function'
|
|
? scriptExports.options
|
|
: scriptExports
|
|
|
|
// render functions
|
|
if (compiledTemplate) {
|
|
options.render = compiledTemplate.render
|
|
options.staticRenderFns = compiledTemplate.staticRenderFns
|
|
}
|
|
|
|
// scopedId
|
|
if (scopeId) {
|
|
options._scopeId = scopeId
|
|
}
|
|
|
|
// inject cssModules
|
|
if (cssModules) {
|
|
var computed = options.computed || (options.computed = {})
|
|
Object.keys(cssModules).forEach(function (key) {
|
|
var module = cssModules[key]
|
|
computed[key] = function () { return module }
|
|
})
|
|
}
|
|
|
|
return {
|
|
esModule: esModule,
|
|
exports: scriptExports,
|
|
options: options
|
|
}
|
|
}
|
|
|
|
|
|
/***/ },
|
|
/* 4 */,
|
|
/* 5 */,
|
|
/* 6 */,
|
|
/* 7 */,
|
|
/* 8 */,
|
|
/* 9 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/input");
|
|
|
|
/***/ },
|
|
/* 10 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/utils/clickoutside");
|
|
|
|
/***/ },
|
|
/* 11 */,
|
|
/* 12 */,
|
|
/* 13 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/utils/vue-popper");
|
|
|
|
/***/ },
|
|
/* 14 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/mixins/emitter");
|
|
|
|
/***/ },
|
|
/* 15 */,
|
|
/* 16 */,
|
|
/* 17 */,
|
|
/* 18 */,
|
|
/* 19 */,
|
|
/* 20 */,
|
|
/* 21 */,
|
|
/* 22 */,
|
|
/* 23 */,
|
|
/* 24 */,
|
|
/* 25 */,
|
|
/* 26 */,
|
|
/* 27 */,
|
|
/* 28 */,
|
|
/* 29 */,
|
|
/* 30 */,
|
|
/* 31 */,
|
|
/* 32 */,
|
|
/* 33 */,
|
|
/* 34 */,
|
|
/* 35 */,
|
|
/* 36 */,
|
|
/* 37 */,
|
|
/* 38 */,
|
|
/* 39 */,
|
|
/* 40 */,
|
|
/* 41 */,
|
|
/* 42 */,
|
|
/* 43 */,
|
|
/* 44 */,
|
|
/* 45 */,
|
|
/* 46 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("throttle-debounce/debounce");
|
|
|
|
/***/ },
|
|
/* 47 */,
|
|
/* 48 */,
|
|
/* 49 */,
|
|
/* 50 */,
|
|
/* 51 */,
|
|
/* 52 */,
|
|
/* 53 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _main = __webpack_require__(54);
|
|
|
|
var _main2 = _interopRequireDefault(_main);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/* istanbul ignore next */
|
|
_main2.default.install = function (Vue) {
|
|
Vue.component(_main2.default.name, _main2.default);
|
|
};
|
|
|
|
exports.default = _main2.default;
|
|
|
|
/***/ },
|
|
/* 54 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(55),
|
|
/* template */
|
|
__webpack_require__(62),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ },
|
|
/* 55 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _vue = __webpack_require__(56);
|
|
|
|
var _vue2 = _interopRequireDefault(_vue);
|
|
|
|
var _menu = __webpack_require__(57);
|
|
|
|
var _menu2 = _interopRequireDefault(_menu);
|
|
|
|
var _input = __webpack_require__(9);
|
|
|
|
var _input2 = _interopRequireDefault(_input);
|
|
|
|
var _vuePopper = __webpack_require__(13);
|
|
|
|
var _vuePopper2 = _interopRequireDefault(_vuePopper);
|
|
|
|
var _clickoutside = __webpack_require__(10);
|
|
|
|
var _clickoutside2 = _interopRequireDefault(_clickoutside);
|
|
|
|
var _emitter = __webpack_require__(14);
|
|
|
|
var _emitter2 = _interopRequireDefault(_emitter);
|
|
|
|
var _locale = __webpack_require__(60);
|
|
|
|
var _locale2 = _interopRequireDefault(_locale);
|
|
|
|
var _locale3 = __webpack_require__(61);
|
|
|
|
var _debounce = __webpack_require__(46);
|
|
|
|
var _debounce2 = _interopRequireDefault(_debounce);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var popperMixin = {
|
|
props: {
|
|
placement: {
|
|
type: String,
|
|
default: 'bottom-start'
|
|
},
|
|
appendToBody: _vuePopper2.default.props.appendToBody,
|
|
offset: _vuePopper2.default.props.offset,
|
|
boundariesPadding: _vuePopper2.default.props.boundariesPadding,
|
|
popperOptions: _vuePopper2.default.props.popperOptions
|
|
},
|
|
methods: _vuePopper2.default.methods,
|
|
data: _vuePopper2.default.data,
|
|
beforeDestroy: _vuePopper2.default.beforeDestroy
|
|
}; //
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
exports.default = {
|
|
name: 'ElCascader',
|
|
|
|
directives: { Clickoutside: _clickoutside2.default },
|
|
|
|
mixins: [popperMixin, _emitter2.default, _locale2.default],
|
|
|
|
components: {
|
|
ElInput: _input2.default
|
|
},
|
|
|
|
props: {
|
|
options: {
|
|
type: Array,
|
|
required: true
|
|
},
|
|
props: {
|
|
type: Object,
|
|
default: function _default() {
|
|
return {
|
|
children: 'children',
|
|
label: 'label',
|
|
value: 'value',
|
|
disabled: 'disabled'
|
|
};
|
|
}
|
|
},
|
|
value: {
|
|
type: Array,
|
|
default: function _default() {
|
|
return [];
|
|
}
|
|
},
|
|
placeholder: {
|
|
type: String,
|
|
default: function _default() {
|
|
return (0, _locale3.t)('el.cascader.placeholder');
|
|
}
|
|
},
|
|
disabled: Boolean,
|
|
clearable: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
changeOnSelect: Boolean,
|
|
popperClass: String,
|
|
expandTrigger: {
|
|
type: String,
|
|
default: 'click'
|
|
},
|
|
filterable: Boolean,
|
|
size: String,
|
|
showAllLevels: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
debounce: {
|
|
type: Number,
|
|
default: 300
|
|
}
|
|
},
|
|
|
|
data: function data() {
|
|
return {
|
|
currentValue: this.value,
|
|
menu: null,
|
|
debouncedInputChange: function debouncedInputChange() {},
|
|
|
|
menuVisible: false,
|
|
inputHover: false,
|
|
inputValue: '',
|
|
flatOptions: null
|
|
};
|
|
},
|
|
|
|
|
|
computed: {
|
|
labelKey: function labelKey() {
|
|
return this.props.label || 'label';
|
|
},
|
|
valueKey: function valueKey() {
|
|
return this.props.value || 'value';
|
|
},
|
|
childrenKey: function childrenKey() {
|
|
return this.props.children || 'children';
|
|
},
|
|
currentLabels: function currentLabels() {
|
|
var _this = this;
|
|
|
|
var options = this.options;
|
|
var labels = [];
|
|
this.currentValue.forEach(function (value) {
|
|
var targetOption = options && options.filter(function (option) {
|
|
return option[_this.valueKey] === value;
|
|
})[0];
|
|
if (targetOption) {
|
|
labels.push(targetOption[_this.labelKey]);
|
|
options = targetOption[_this.childrenKey];
|
|
}
|
|
});
|
|
return labels;
|
|
}
|
|
},
|
|
|
|
watch: {
|
|
menuVisible: function menuVisible(value) {
|
|
value ? this.showMenu() : this.hideMenu();
|
|
},
|
|
value: function value(_value) {
|
|
this.currentValue = _value;
|
|
},
|
|
currentValue: function currentValue(value) {
|
|
this.dispatch('ElFormItem', 'el.form.change', [value]);
|
|
},
|
|
|
|
options: {
|
|
deep: true,
|
|
handler: function handler(value) {
|
|
if (!this.menu) {
|
|
this.initMenu();
|
|
}
|
|
this.flatOptions = this.flattenOptions(this.options);
|
|
this.menu.options = value;
|
|
}
|
|
}
|
|
},
|
|
|
|
methods: {
|
|
initMenu: function initMenu() {
|
|
this.menu = new _vue2.default(_menu2.default).$mount();
|
|
this.menu.options = this.options;
|
|
this.menu.props = this.props;
|
|
this.menu.expandTrigger = this.expandTrigger;
|
|
this.menu.changeOnSelect = this.changeOnSelect;
|
|
this.menu.popperClass = this.popperClass;
|
|
this.popperElm = this.menu.$el;
|
|
this.menu.$on('pick', this.handlePick);
|
|
this.menu.$on('activeItemChange', this.handleActiveItemChange);
|
|
this.menu.$on('menuLeave', this.doDestroy);
|
|
},
|
|
showMenu: function showMenu() {
|
|
var _this2 = this;
|
|
|
|
if (!this.menu) {
|
|
this.initMenu();
|
|
}
|
|
|
|
this.menu.value = this.currentValue.slice(0);
|
|
this.menu.visible = true;
|
|
this.menu.options = this.options;
|
|
this.$nextTick(function (_) {
|
|
_this2.updatePopper();
|
|
_this2.menu.inputWidth = _this2.$refs.input.$el.offsetWidth - 2;
|
|
});
|
|
},
|
|
hideMenu: function hideMenu() {
|
|
this.inputValue = '';
|
|
this.menu.visible = false;
|
|
},
|
|
handleActiveItemChange: function handleActiveItemChange(value) {
|
|
var _this3 = this;
|
|
|
|
this.$nextTick(function (_) {
|
|
_this3.updatePopper();
|
|
});
|
|
this.$emit('active-item-change', value);
|
|
},
|
|
handlePick: function handlePick(value) {
|
|
var close = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
|
|
|
|
this.currentValue = value;
|
|
this.$emit('input', value);
|
|
this.$emit('change', value);
|
|
|
|
if (close) {
|
|
this.menuVisible = false;
|
|
}
|
|
},
|
|
handleInputChange: function handleInputChange(value) {
|
|
var _this4 = this;
|
|
|
|
if (!this.menuVisible) return;
|
|
var flatOptions = this.flatOptions;
|
|
|
|
if (!value) {
|
|
this.menu.options = this.options;
|
|
return;
|
|
}
|
|
|
|
var filteredFlatOptions = flatOptions.filter(function (optionsStack) {
|
|
return optionsStack.some(function (option) {
|
|
return new RegExp(value, 'i').test(option[_this4.labelKey]);
|
|
});
|
|
});
|
|
|
|
if (filteredFlatOptions.length > 0) {
|
|
filteredFlatOptions = filteredFlatOptions.map(function (optionStack) {
|
|
return {
|
|
__IS__FLAT__OPTIONS: true,
|
|
value: optionStack.map(function (item) {
|
|
return item[_this4.valueKey];
|
|
}),
|
|
label: _this4.renderFilteredOptionLabel(value, optionStack)
|
|
};
|
|
});
|
|
} else {
|
|
filteredFlatOptions = [{
|
|
__IS__FLAT__OPTIONS: true,
|
|
label: this.t('el.cascader.noMatch'),
|
|
value: '',
|
|
disabled: true
|
|
}];
|
|
}
|
|
this.menu.options = filteredFlatOptions;
|
|
},
|
|
renderFilteredOptionLabel: function renderFilteredOptionLabel(inputValue, optionsStack) {
|
|
var _this5 = this;
|
|
|
|
return optionsStack.map(function (option, index) {
|
|
var label = option[_this5.labelKey];
|
|
var keywordIndex = label.toLowerCase().indexOf(inputValue.toLowerCase());
|
|
var labelPart = label.slice(keywordIndex, inputValue.length + keywordIndex);
|
|
var node = keywordIndex > -1 ? _this5.highlightKeyword(label, labelPart) : label;
|
|
return index === 0 ? node : [' / ', node];
|
|
});
|
|
},
|
|
highlightKeyword: function highlightKeyword(label, keyword) {
|
|
var _this6 = this;
|
|
|
|
var h = this._c;
|
|
return label.split(keyword).map(function (node, index) {
|
|
return index === 0 ? node : [h('span', { class: { 'el-cascader-menu__item__keyword': true } }, [_this6._v(keyword)]), node];
|
|
});
|
|
},
|
|
flattenOptions: function flattenOptions(options) {
|
|
var _this7 = this;
|
|
|
|
var ancestor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
|
|
var flatOptions = [];
|
|
options.forEach(function (option) {
|
|
var optionsStack = ancestor.concat(option);
|
|
if (!option[_this7.childrenKey]) {
|
|
flatOptions.push(optionsStack);
|
|
} else {
|
|
if (_this7.changeOnSelect) {
|
|
flatOptions.push(optionsStack);
|
|
}
|
|
flatOptions = flatOptions.concat(_this7.flattenOptions(option[_this7.childrenKey], optionsStack));
|
|
}
|
|
});
|
|
return flatOptions;
|
|
},
|
|
clearValue: function clearValue(ev) {
|
|
ev.stopPropagation();
|
|
this.handlePick([], true);
|
|
},
|
|
handleClickoutside: function handleClickoutside() {
|
|
this.menuVisible = false;
|
|
},
|
|
handleClick: function handleClick() {
|
|
if (this.disabled) return;
|
|
if (this.filterable) {
|
|
this.menuVisible = true;
|
|
this.$refs.input.$refs.input.focus();
|
|
return;
|
|
}
|
|
this.menuVisible = !this.menuVisible;
|
|
}
|
|
},
|
|
|
|
created: function created() {
|
|
var _this8 = this;
|
|
|
|
this.debouncedInputChange = (0, _debounce2.default)(this.debounce, function (value) {
|
|
_this8.handleInputChange(value);
|
|
});
|
|
},
|
|
mounted: function mounted() {
|
|
this.flatOptions = this.flattenOptions(this.options);
|
|
}
|
|
};
|
|
|
|
/***/ },
|
|
/* 56 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("vue");
|
|
|
|
/***/ },
|
|
/* 57 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(58),
|
|
/* template */
|
|
null,
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ },
|
|
/* 58 */
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _babelHelperVueJsxMergeProps = __webpack_require__(59);
|
|
|
|
var _babelHelperVueJsxMergeProps2 = _interopRequireDefault(_babelHelperVueJsxMergeProps);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = {
|
|
name: 'ElCascaderMenu',
|
|
|
|
data: function data() {
|
|
return {
|
|
inputWidth: 0,
|
|
options: [],
|
|
props: {},
|
|
visible: false,
|
|
activeValue: [],
|
|
value: [],
|
|
expandTrigger: 'click',
|
|
changeOnSelect: false,
|
|
popperClass: ''
|
|
};
|
|
},
|
|
|
|
|
|
watch: {
|
|
visible: function visible(value) {
|
|
if (value) {
|
|
this.activeValue = this.value;
|
|
}
|
|
},
|
|
|
|
value: {
|
|
immediate: true,
|
|
handler: function handler(value) {
|
|
this.activeValue = value;
|
|
}
|
|
}
|
|
},
|
|
|
|
computed: {
|
|
activeOptions: {
|
|
cache: false,
|
|
get: function get() {
|
|
var _this = this;
|
|
|
|
var activeValue = this.activeValue;
|
|
var configurableProps = ['label', 'value', 'children', 'disabled'];
|
|
|
|
var formatOptions = function formatOptions(options) {
|
|
options.forEach(function (option) {
|
|
if (option.__IS__FLAT__OPTIONS) return;
|
|
configurableProps.forEach(function (prop) {
|
|
var value = option[_this.props[prop] || prop];
|
|
if (value) option[prop] = value;
|
|
});
|
|
if (Array.isArray(option.children)) {
|
|
formatOptions(option.children);
|
|
}
|
|
});
|
|
};
|
|
|
|
var loadActiveOptions = function loadActiveOptions(options) {
|
|
var activeOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
|
|
var level = activeOptions.length;
|
|
activeOptions[level] = options;
|
|
var active = activeValue[level];
|
|
if (active) {
|
|
options = options.filter(function (option) {
|
|
return option.value === active;
|
|
})[0];
|
|
if (options && options.children) {
|
|
loadActiveOptions(options.children, activeOptions);
|
|
}
|
|
}
|
|
return activeOptions;
|
|
};
|
|
|
|
formatOptions(this.options);
|
|
return loadActiveOptions(this.options);
|
|
}
|
|
}
|
|
},
|
|
|
|
methods: {
|
|
select: function select(item, menuIndex) {
|
|
if (item.__IS__FLAT__OPTIONS) {
|
|
this.activeValue = item.value;
|
|
} else if (menuIndex) {
|
|
this.activeValue.splice(menuIndex, this.activeValue.length - 1, item.value);
|
|
} else {
|
|
this.activeValue = [item.value];
|
|
}
|
|
this.$emit('pick', this.activeValue);
|
|
},
|
|
handleMenuLeave: function handleMenuLeave() {
|
|
this.$emit('menuLeave');
|
|
},
|
|
activeItem: function activeItem(item, menuIndex) {
|
|
var len = this.activeOptions.length;
|
|
this.activeValue.splice(menuIndex, len, item.value);
|
|
this.activeOptions.splice(menuIndex + 1, len, item.children);
|
|
if (this.changeOnSelect) {
|
|
this.$emit('pick', this.activeValue, false);
|
|
} else {
|
|
this.$emit('activeItemChange', this.activeValue);
|
|
}
|
|
}
|
|
},
|
|
|
|
render: function render(h) {
|
|
var _this2 = this;
|
|
|
|
var activeValue = this.activeValue,
|
|
activeOptions = this.activeOptions,
|
|
visible = this.visible,
|
|
expandTrigger = this.expandTrigger,
|
|
popperClass = this.popperClass;
|
|
|
|
|
|
var menus = this._l(activeOptions, function (menu, menuIndex) {
|
|
var isFlat = false;
|
|
var items = _this2._l(menu, function (item) {
|
|
var events = {
|
|
on: {}
|
|
};
|
|
|
|
if (item.__IS__FLAT__OPTIONS) isFlat = true;
|
|
|
|
if (!item.disabled) {
|
|
if (item.children) {
|
|
var triggerEvent = {
|
|
click: 'click',
|
|
hover: 'mouseenter'
|
|
}[expandTrigger];
|
|
events.on[triggerEvent] = function () {
|
|
_this2.activeItem(item, menuIndex);
|
|
};
|
|
} else {
|
|
events.on.click = function () {
|
|
_this2.select(item, menuIndex);
|
|
};
|
|
}
|
|
}
|
|
|
|
return h(
|
|
'li',
|
|
(0, _babelHelperVueJsxMergeProps2.default)([{
|
|
'class': {
|
|
'el-cascader-menu__item': true,
|
|
'el-cascader-menu__item--extensible': item.children,
|
|
'is-active': item.value === activeValue[menuIndex],
|
|
'is-disabled': item.disabled
|
|
}
|
|
}, events]),
|
|
[item.label]
|
|
);
|
|
});
|
|
var menuStyle = {};
|
|
if (isFlat) {
|
|
menuStyle.minWidth = _this2.inputWidth + 'px';
|
|
}
|
|
|
|
return h(
|
|
'ul',
|
|
{
|
|
'class': {
|
|
'el-cascader-menu': true,
|
|
'el-cascader-menu--flexible': isFlat
|
|
},
|
|
style: menuStyle },
|
|
[items]
|
|
);
|
|
});
|
|
return h(
|
|
'transition',
|
|
{
|
|
attrs: { name: 'el-zoom-in-top' },
|
|
on: {
|
|
'after-leave': this.handleMenuLeave
|
|
}
|
|
},
|
|
[h(
|
|
'div',
|
|
{
|
|
directives: [{
|
|
name: 'show',
|
|
value: visible
|
|
}],
|
|
|
|
'class': ['el-cascader-menus', popperClass]
|
|
},
|
|
[menus]
|
|
)]
|
|
);
|
|
}
|
|
};
|
|
|
|
/***/ },
|
|
/* 59 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("babel-helper-vue-jsx-merge-props");
|
|
|
|
/***/ },
|
|
/* 60 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/mixins/locale");
|
|
|
|
/***/ },
|
|
/* 61 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/locale");
|
|
|
|
/***/ },
|
|
/* 62 */
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('span', {
|
|
directives: [{
|
|
name: "clickoutside",
|
|
rawName: "v-clickoutside",
|
|
value: (_vm.handleClickoutside),
|
|
expression: "handleClickoutside"
|
|
}],
|
|
ref: "reference",
|
|
staticClass: "el-cascader",
|
|
class: [{
|
|
'is-opened': _vm.menuVisible,
|
|
'is-disabled': _vm.disabled
|
|
},
|
|
_vm.size ? 'el-cascader--' + _vm.size : ''
|
|
],
|
|
on: {
|
|
"click": _vm.handleClick,
|
|
"mouseenter": function($event) {
|
|
_vm.inputHover = true
|
|
},
|
|
"mouseleave": function($event) {
|
|
_vm.inputHover = false
|
|
}
|
|
}
|
|
}, [_c('el-input', {
|
|
directives: [{
|
|
name: "model",
|
|
rawName: "v-model",
|
|
value: (_vm.inputValue),
|
|
expression: "inputValue"
|
|
}],
|
|
ref: "input",
|
|
attrs: {
|
|
"readonly": !_vm.filterable,
|
|
"placeholder": _vm.currentLabels.length ? undefined : _vm.placeholder,
|
|
"validate-event": false,
|
|
"size": _vm.size,
|
|
"disabled": _vm.disabled
|
|
},
|
|
domProps: {
|
|
"value": (_vm.inputValue)
|
|
},
|
|
on: {
|
|
"change": _vm.debouncedInputChange,
|
|
"input": function($event) {
|
|
_vm.inputValue = $event
|
|
}
|
|
}
|
|
}, [_c('template', {
|
|
slot: "icon"
|
|
}, [(_vm.clearable && _vm.inputHover && _vm.currentLabels.length) ? _c('i', {
|
|
key: "1",
|
|
staticClass: "el-input__icon el-icon-circle-close el-cascader__clearIcon",
|
|
on: {
|
|
"click": _vm.clearValue
|
|
}
|
|
}) : _c('i', {
|
|
key: "2",
|
|
staticClass: "el-input__icon el-icon-caret-bottom",
|
|
class: {
|
|
'is-reverse': _vm.menuVisible
|
|
}
|
|
})])], 2), _c('span', {
|
|
directives: [{
|
|
name: "show",
|
|
rawName: "v-show",
|
|
value: (_vm.inputValue === ''),
|
|
expression: "inputValue === ''"
|
|
}],
|
|
staticClass: "el-cascader__label"
|
|
}, [(_vm.showAllLevels) ? [_vm._l((_vm.currentLabels), function(label, index) {
|
|
return [_vm._v("\n " + _vm._s(label) + "\n "), (index < _vm.currentLabels.length - 1) ? _c('span', [_vm._v(" / ")]) : _vm._e()]
|
|
})] : [_vm._v("\n " + _vm._s(_vm.currentLabels[_vm.currentLabels.length - 1]) + "\n ")]], 2)], 1)
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }
|
|
/******/ ]); |