1 | module.exports =
|
2 | (function(modules) {
|
3 |
|
4 | var installedModules = {};
|
5 |
|
6 |
|
7 | function __webpack_require__(moduleId) {
|
8 |
|
9 |
|
10 | if(installedModules[moduleId]) {
|
11 | return installedModules[moduleId].exports;
|
12 | }
|
13 |
|
14 | var module = installedModules[moduleId] = {
|
15 | i: moduleId,
|
16 | l: false,
|
17 | exports: {}
|
18 | };
|
19 |
|
20 |
|
21 | modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
22 |
|
23 |
|
24 | module.l = true;
|
25 |
|
26 |
|
27 | return module.exports;
|
28 | }
|
29 |
|
30 |
|
31 |
|
32 | __webpack_require__.m = modules;
|
33 |
|
34 |
|
35 | __webpack_require__.c = installedModules;
|
36 |
|
37 |
|
38 | __webpack_require__.d = function(exports, name, getter) {
|
39 | if(!__webpack_require__.o(exports, name)) {
|
40 | Object.defineProperty(exports, name, { enumerable: true, get: getter });
|
41 | }
|
42 | };
|
43 |
|
44 |
|
45 | __webpack_require__.r = function(exports) {
|
46 | if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
47 | Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
48 | }
|
49 | Object.defineProperty(exports, '__esModule', { value: true });
|
50 | };
|
51 |
|
52 |
|
53 |
|
54 |
|
55 |
|
56 |
|
57 | __webpack_require__.t = function(value, mode) {
|
58 | if(mode & 1) value = __webpack_require__(value);
|
59 | if(mode & 8) return value;
|
60 | if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
|
61 | var ns = Object.create(null);
|
62 | __webpack_require__.r(ns);
|
63 | Object.defineProperty(ns, 'default', { enumerable: true, value: value });
|
64 | if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
|
65 | return ns;
|
66 | };
|
67 |
|
68 |
|
69 | __webpack_require__.n = function(module) {
|
70 | var getter = module && module.__esModule ?
|
71 | function getDefault() { return module['default']; } :
|
72 | function getModuleExports() { return module; };
|
73 | __webpack_require__.d(getter, 'a', getter);
|
74 | return getter;
|
75 | };
|
76 |
|
77 |
|
78 | __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
79 |
|
80 |
|
81 | __webpack_require__.p = "/dist/";
|
82 |
|
83 |
|
84 |
|
85 | return __webpack_require__(__webpack_require__.s = 126);
|
86 | })
|
87 |
|
88 | ({
|
89 |
|
90 | 126:
|
91 | (function(module, __webpack_exports__, __webpack_require__) {
|
92 |
|
93 | "use strict";
|
94 | __webpack_require__.r(__webpack_exports__);
|
95 |
|
96 |
|
97 | var util_ = __webpack_require__(3);
|
98 |
|
99 |
|
100 |
|
101 |
|
102 | var cellStarts = {
|
103 | default: {
|
104 | order: ''
|
105 | },
|
106 | selection: {
|
107 | width: 48,
|
108 | minWidth: 48,
|
109 | realWidth: 48,
|
110 | order: '',
|
111 | className: 'el-table-column--selection'
|
112 | },
|
113 | expand: {
|
114 | width: 48,
|
115 | minWidth: 48,
|
116 | realWidth: 48,
|
117 | order: ''
|
118 | },
|
119 | index: {
|
120 | width: 48,
|
121 | minWidth: 48,
|
122 | realWidth: 48,
|
123 | order: ''
|
124 | }
|
125 | };
|
126 |
|
127 |
|
128 | var cellForced = {
|
129 | selection: {
|
130 | renderHeader: function renderHeader(h, _ref) {
|
131 | var store = _ref.store;
|
132 |
|
133 | return h('el-checkbox', {
|
134 | attrs: {
|
135 | disabled: store.states.data && store.states.data.length === 0,
|
136 | indeterminate: store.states.selection.length > 0 && !this.isAllSelected,
|
137 |
|
138 | value: this.isAllSelected },
|
139 | nativeOn: {
|
140 | 'click': this.toggleAllSelection
|
141 | }
|
142 | });
|
143 | },
|
144 | renderCell: function renderCell(h, _ref2) {
|
145 | var row = _ref2.row,
|
146 | column = _ref2.column,
|
147 | store = _ref2.store,
|
148 | $index = _ref2.$index;
|
149 |
|
150 | return h('el-checkbox', {
|
151 | nativeOn: {
|
152 | 'click': function click(event) {
|
153 | return event.stopPropagation();
|
154 | }
|
155 | },
|
156 | attrs: {
|
157 | value: store.isSelected(row),
|
158 | disabled: column.selectable ? !column.selectable.call(null, row, $index) : false
|
159 | },
|
160 | on: {
|
161 | 'input': function input() {
|
162 | store.commit('rowSelectedChanged', row);
|
163 | }
|
164 | }
|
165 | });
|
166 | },
|
167 | sortable: false,
|
168 | resizable: false
|
169 | },
|
170 | index: {
|
171 | renderHeader: function renderHeader(h, _ref3) {
|
172 | var column = _ref3.column;
|
173 |
|
174 | return column.label || '#';
|
175 | },
|
176 | renderCell: function renderCell(h, _ref4) {
|
177 | var $index = _ref4.$index,
|
178 | column = _ref4.column;
|
179 |
|
180 | var i = $index + 1;
|
181 | var index = column.index;
|
182 |
|
183 | if (typeof index === 'number') {
|
184 | i = $index + index;
|
185 | } else if (typeof index === 'function') {
|
186 | i = index($index);
|
187 | }
|
188 |
|
189 | return h('div', [i]);
|
190 | },
|
191 | sortable: false
|
192 | },
|
193 | expand: {
|
194 | renderHeader: function renderHeader(h, _ref5) {
|
195 | var column = _ref5.column;
|
196 |
|
197 | return column.label || '';
|
198 | },
|
199 | renderCell: function renderCell(h, _ref6) {
|
200 | var row = _ref6.row,
|
201 | store = _ref6.store;
|
202 |
|
203 | var classes = ['el-table__expand-icon'];
|
204 | if (store.states.expandRows.indexOf(row) > -1) {
|
205 | classes.push('el-table__expand-icon--expanded');
|
206 | }
|
207 | var callback = function callback(e) {
|
208 | e.stopPropagation();
|
209 | store.toggleRowExpansion(row);
|
210 | };
|
211 | return h(
|
212 | 'div',
|
213 | { 'class': classes,
|
214 | on: {
|
215 | 'click': callback
|
216 | }
|
217 | },
|
218 | [h('i', { 'class': 'el-icon el-icon-arrow-right' })]
|
219 | );
|
220 | },
|
221 | sortable: false,
|
222 | resizable: false,
|
223 | className: 'el-table__expand-column'
|
224 | }
|
225 | };
|
226 |
|
227 | function defaultRenderCell(h, _ref7) {
|
228 | var row = _ref7.row,
|
229 | column = _ref7.column,
|
230 | $index = _ref7.$index;
|
231 |
|
232 | var property = column.property;
|
233 | var value = property && Object(util_["getPropByPath"])(row, property).v;
|
234 | if (column && column.formatter) {
|
235 | return column.formatter(row, column, value, $index);
|
236 | }
|
237 | return value;
|
238 | }
|
239 |
|
240 | function treeCellPrefix(h, _ref8) {
|
241 | var row = _ref8.row,
|
242 | treeNode = _ref8.treeNode,
|
243 | store = _ref8.store;
|
244 |
|
245 | if (!treeNode) return null;
|
246 | var ele = [];
|
247 | var callback = function callback(e) {
|
248 | e.stopPropagation();
|
249 | store.loadOrToggle(row);
|
250 | };
|
251 | if (treeNode.indent) {
|
252 | ele.push(h('span', { 'class': 'el-table__indent', style: { 'padding-left': treeNode.indent + 'px' } }));
|
253 | }
|
254 | if (typeof treeNode.expanded === 'boolean' && !treeNode.noLazyChildren) {
|
255 | var expandClasses = ['el-table__expand-icon', treeNode.expanded ? 'el-table__expand-icon--expanded' : ''];
|
256 | var iconClasses = ['el-icon-arrow-right'];
|
257 | if (treeNode.loading) {
|
258 | iconClasses = ['el-icon-loading'];
|
259 | }
|
260 | ele.push(h(
|
261 | 'div',
|
262 | { 'class': expandClasses,
|
263 | on: {
|
264 | 'click': callback
|
265 | }
|
266 | },
|
267 | [h('i', { 'class': iconClasses })]
|
268 | ));
|
269 | } else {
|
270 | ele.push(h('span', { 'class': 'el-table__placeholder' }));
|
271 | }
|
272 | return ele;
|
273 | }
|
274 |
|
275 | var util = __webpack_require__(8);
|
276 |
|
277 |
|
278 | var checkbox_ = __webpack_require__(17);
|
279 | var checkbox_default = __webpack_require__.n(checkbox_);
|
280 |
|
281 |
|
282 | var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
283 |
|
284 |
|
285 |
|
286 |
|
287 |
|
288 | var columnIdSeed = 1;
|
289 |
|
290 | var table_column = ({
|
291 | name: 'ElTableColumn',
|
292 |
|
293 | props: {
|
294 | type: {
|
295 | type: String,
|
296 | default: 'default'
|
297 | },
|
298 | label: String,
|
299 | className: String,
|
300 | labelClassName: String,
|
301 | property: String,
|
302 | prop: String,
|
303 | width: {},
|
304 | minWidth: {},
|
305 | renderHeader: Function,
|
306 | sortable: {
|
307 | type: [Boolean, String],
|
308 | default: false
|
309 | },
|
310 | sortMethod: Function,
|
311 | sortBy: [String, Function, Array],
|
312 | resizable: {
|
313 | type: Boolean,
|
314 | default: true
|
315 | },
|
316 | columnKey: String,
|
317 | align: String,
|
318 | headerAlign: String,
|
319 | showTooltipWhenOverflow: Boolean,
|
320 | showOverflowTooltip: Boolean,
|
321 | fixed: [Boolean, String],
|
322 | formatter: Function,
|
323 | selectable: Function,
|
324 | reserveSelection: Boolean,
|
325 | filterMethod: Function,
|
326 | filteredValue: Array,
|
327 | filters: Array,
|
328 | filterPlacement: String,
|
329 | filterMultiple: {
|
330 | type: Boolean,
|
331 | default: true
|
332 | },
|
333 | index: [Number, Function],
|
334 | sortOrders: {
|
335 | type: Array,
|
336 | default: function _default() {
|
337 | return ['ascending', 'descending', null];
|
338 | },
|
339 | validator: function validator(val) {
|
340 | return val.every(function (order) {
|
341 | return ['ascending', 'descending', null].indexOf(order) > -1;
|
342 | });
|
343 | }
|
344 | }
|
345 | },
|
346 |
|
347 | data: function data() {
|
348 | return {
|
349 | isSubColumn: false,
|
350 | columns: []
|
351 | };
|
352 | },
|
353 |
|
354 |
|
355 | computed: {
|
356 | owner: function owner() {
|
357 | var parent = this.$parent;
|
358 | while (parent && !parent.tableId) {
|
359 | parent = parent.$parent;
|
360 | }
|
361 | return parent;
|
362 | },
|
363 | columnOrTableParent: function columnOrTableParent() {
|
364 | var parent = this.$parent;
|
365 | while (parent && !parent.tableId && !parent.columnId) {
|
366 | parent = parent.$parent;
|
367 | }
|
368 | return parent;
|
369 | },
|
370 | realWidth: function realWidth() {
|
371 | return Object(util["l" ])(this.width);
|
372 | },
|
373 | realMinWidth: function realMinWidth() {
|
374 | return Object(util["k" ])(this.minWidth);
|
375 | },
|
376 | realAlign: function realAlign() {
|
377 | return this.align ? 'is-' + this.align : null;
|
378 | },
|
379 | realHeaderAlign: function realHeaderAlign() {
|
380 | return this.headerAlign ? 'is-' + this.headerAlign : this.realAlign;
|
381 | }
|
382 | },
|
383 |
|
384 | methods: {
|
385 | getPropsData: function getPropsData() {
|
386 | var _this = this;
|
387 |
|
388 | for (var _len = arguments.length, props = Array(_len), _key = 0; _key < _len; _key++) {
|
389 | props[_key] = arguments[_key];
|
390 | }
|
391 |
|
392 | return props.reduce(function (prev, cur) {
|
393 | if (Array.isArray(cur)) {
|
394 | cur.forEach(function (key) {
|
395 | prev[key] = _this[key];
|
396 | });
|
397 | }
|
398 | return prev;
|
399 | }, {});
|
400 | },
|
401 | getColumnElIndex: function getColumnElIndex(children, child) {
|
402 | return [].indexOf.call(children, child);
|
403 | },
|
404 | setColumnWidth: function setColumnWidth(column) {
|
405 | if (this.realWidth) {
|
406 | column.width = this.realWidth;
|
407 | }
|
408 | if (this.realMinWidth) {
|
409 | column.minWidth = this.realMinWidth;
|
410 | }
|
411 | if (!column.minWidth) {
|
412 | column.minWidth = 80;
|
413 | }
|
414 | column.realWidth = column.width === undefined ? column.minWidth : column.width;
|
415 | return column;
|
416 | },
|
417 | setColumnForcedProps: function setColumnForcedProps(column) {
|
418 |
|
419 | var type = column.type;
|
420 | var source = cellForced[type] || {};
|
421 | Object.keys(source).forEach(function (prop) {
|
422 | var value = source[prop];
|
423 | if (value !== undefined) {
|
424 | column[prop] = prop === 'className' ? column[prop] + ' ' + value : value;
|
425 | }
|
426 | });
|
427 | return column;
|
428 | },
|
429 | setColumnRenders: function setColumnRenders(column) {
|
430 | var _this2 = this;
|
431 |
|
432 | var h = this.$createElement;
|
433 |
|
434 | var specialTypes = Object.keys(cellForced);
|
435 |
|
436 | if (this.renderHeader) {
|
437 | console.warn('[Element Warn][TableColumn]Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.');
|
438 | } else if (specialTypes.indexOf(column.type) === -1) {
|
439 | column.renderHeader = function (h, scope) {
|
440 | var renderHeader = _this2.$scopedSlots.header;
|
441 | return renderHeader ? renderHeader(scope) : column.label;
|
442 | };
|
443 | }
|
444 |
|
445 | var originRenderCell = column.renderCell;
|
446 |
|
447 | if (column.type === 'expand') {
|
448 |
|
449 | column.renderCell = function (h, data) {
|
450 | return h(
|
451 | 'div',
|
452 | { 'class': 'cell' },
|
453 | [originRenderCell(h, data)]
|
454 | );
|
455 | };
|
456 | this.owner.renderExpanded = function (h, data) {
|
457 | return _this2.$scopedSlots.default ? _this2.$scopedSlots.default(data) : _this2.$slots.default;
|
458 | };
|
459 | } else {
|
460 | originRenderCell = originRenderCell || defaultRenderCell;
|
461 |
|
462 | column.renderCell = function (h, data) {
|
463 | var children = null;
|
464 | if (_this2.$scopedSlots.default) {
|
465 | children = _this2.$scopedSlots.default(data);
|
466 | } else {
|
467 | children = originRenderCell(h, data);
|
468 | }
|
469 | var prefix = treeCellPrefix(h, data);
|
470 | var props = {
|
471 | class: 'cell',
|
472 | style: {}
|
473 | };
|
474 | if (column.showOverflowTooltip) {
|
475 | props.class += ' el-tooltip';
|
476 | props.style = { width: (data.column.realWidth || data.column.width) - 1 + 'px' };
|
477 | }
|
478 | return h(
|
479 | 'div',
|
480 | props,
|
481 | [prefix, children]
|
482 | );
|
483 | };
|
484 | }
|
485 | return column;
|
486 | },
|
487 | registerNormalWatchers: function registerNormalWatchers() {
|
488 | var _this3 = this;
|
489 |
|
490 | var props = ['label', 'property', 'filters', 'filterMultiple', 'sortable', 'index', 'formatter', 'className', 'labelClassName', 'showOverflowTooltip'];
|
491 |
|
492 | var aliases = {
|
493 | prop: 'property',
|
494 | realAlign: 'align',
|
495 | realHeaderAlign: 'headerAlign',
|
496 | realWidth: 'width'
|
497 | };
|
498 | var allAliases = props.reduce(function (prev, cur) {
|
499 | prev[cur] = cur;
|
500 | return prev;
|
501 | }, aliases);
|
502 |
|
503 | Object.keys(allAliases).forEach(function (key) {
|
504 | var columnKey = aliases[key];
|
505 |
|
506 | _this3.$watch(key, function (newVal) {
|
507 | _this3.columnConfig[columnKey] = newVal;
|
508 | });
|
509 | });
|
510 | },
|
511 | registerComplexWatchers: function registerComplexWatchers() {
|
512 | var _this4 = this;
|
513 |
|
514 | var props = ['fixed'];
|
515 | var aliases = {
|
516 | realWidth: 'width',
|
517 | realMinWidth: 'minWidth'
|
518 | };
|
519 | var allAliases = props.reduce(function (prev, cur) {
|
520 | prev[cur] = cur;
|
521 | return prev;
|
522 | }, aliases);
|
523 |
|
524 | Object.keys(allAliases).forEach(function (key) {
|
525 | var columnKey = aliases[key];
|
526 |
|
527 | _this4.$watch(key, function (newVal) {
|
528 | _this4.columnConfig[columnKey] = newVal;
|
529 | var updateColumns = columnKey === 'fixed';
|
530 | _this4.owner.store.scheduleLayout(updateColumns);
|
531 | });
|
532 | });
|
533 | }
|
534 | },
|
535 |
|
536 | components: {
|
537 | ElCheckbox: checkbox_default.a
|
538 | },
|
539 |
|
540 | beforeCreate: function beforeCreate() {
|
541 | this.row = {};
|
542 | this.column = {};
|
543 | this.$index = 0;
|
544 | this.columnId = '';
|
545 | },
|
546 | created: function created() {
|
547 | var parent = this.columnOrTableParent;
|
548 | this.isSubColumn = this.owner !== parent;
|
549 | this.columnId = (parent.tableId || parent.columnId) + '_column_' + columnIdSeed++;
|
550 |
|
551 | var type = this.type || 'default';
|
552 | var sortable = this.sortable === '' ? true : this.sortable;
|
553 | var defaults = _extends({}, cellStarts[type], {
|
554 | id: this.columnId,
|
555 | type: type,
|
556 | property: this.prop || this.property,
|
557 | align: this.realAlign,
|
558 | headerAlign: this.realHeaderAlign,
|
559 | showOverflowTooltip: this.showOverflowTooltip || this.showTooltipWhenOverflow,
|
560 |
|
561 | filterable: this.filters || this.filterMethod,
|
562 | filteredValue: [],
|
563 | filterPlacement: '',
|
564 | isColumnGroup: false,
|
565 | filterOpened: false,
|
566 |
|
567 | sortable: sortable,
|
568 |
|
569 | index: this.index
|
570 | });
|
571 |
|
572 | var basicProps = ['columnKey', 'label', 'className', 'labelClassName', 'type', 'renderHeader', 'formatter', 'fixed', 'resizable'];
|
573 | var sortProps = ['sortMethod', 'sortBy', 'sortOrders'];
|
574 | var selectProps = ['selectable', 'reserveSelection'];
|
575 | var filterProps = ['filterMethod', 'filters', 'filterMultiple', 'filterOpened', 'filteredValue', 'filterPlacement'];
|
576 |
|
577 | var column = this.getPropsData(basicProps, sortProps, selectProps, filterProps);
|
578 | column = Object(util["h" ])(defaults, column);
|
579 |
|
580 |
|
581 | var chains = Object(util["a" ])(this.setColumnRenders, this.setColumnWidth, this.setColumnForcedProps);
|
582 | column = chains(column);
|
583 |
|
584 | this.columnConfig = column;
|
585 |
|
586 |
|
587 | this.registerNormalWatchers();
|
588 | this.registerComplexWatchers();
|
589 | },
|
590 | mounted: function mounted() {
|
591 | var owner = this.owner;
|
592 | var parent = this.columnOrTableParent;
|
593 | var children = this.isSubColumn ? parent.$el.children : parent.$refs.hiddenColumns.children;
|
594 | var columnIndex = this.getColumnElIndex(children, this.$el);
|
595 |
|
596 | owner.store.commit('insertColumn', this.columnConfig, columnIndex, this.isSubColumn ? parent.columnConfig : null);
|
597 | },
|
598 | destroyed: function destroyed() {
|
599 | if (!this.$parent) return;
|
600 | var parent = this.$parent;
|
601 | this.owner.store.commit('removeColumn', this.columnConfig, this.isSubColumn ? parent.columnConfig : null);
|
602 | },
|
603 | render: function render(h) {
|
604 |
|
605 | return h('div', this.$slots.default);
|
606 | }
|
607 | });
|
608 |
|
609 |
|
610 |
|
611 |
|
612 | table_column.install = function (Vue) {
|
613 | Vue.component(table_column.name, table_column);
|
614 | };
|
615 |
|
616 | var packages_table_column = __webpack_exports__["default"] = (table_column);
|
617 |
|
618 | }),
|
619 |
|
620 | 17:
|
621 | (function(module, exports) {
|
622 |
|
623 | module.exports = require("element-ui/lib/checkbox");
|
624 |
|
625 | }),
|
626 |
|
627 | 3:
|
628 | (function(module, exports) {
|
629 |
|
630 | module.exports = require("element-ui/lib/utils/util");
|
631 |
|
632 | }),
|
633 |
|
634 | 8:
|
635 | (function(module, __webpack_exports__, __webpack_require__) {
|
636 |
|
637 | "use strict";
|
638 | __webpack_require__.d(__webpack_exports__, "b", function() { return getCell; });
|
639 | __webpack_require__.d(__webpack_exports__, "i", function() { return orderBy; });
|
640 | __webpack_require__.d(__webpack_exports__, "d", function() { return getColumnById; });
|
641 | __webpack_require__.d(__webpack_exports__, "e", function() { return getColumnByKey; });
|
642 | __webpack_require__.d(__webpack_exports__, "c", function() { return getColumnByCell; });
|
643 | __webpack_require__.d(__webpack_exports__, "g", function() { return getRowIdentity; });
|
644 | __webpack_require__.d(__webpack_exports__, "f", function() { return getKeysMap; });
|
645 | __webpack_require__.d(__webpack_exports__, "h", function() { return mergeOptions; });
|
646 | __webpack_require__.d(__webpack_exports__, "l", function() { return parseWidth; });
|
647 | __webpack_require__.d(__webpack_exports__, "k", function() { return parseMinWidth; });
|
648 | __webpack_require__.d(__webpack_exports__, "j", function() { return parseHeight; });
|
649 | __webpack_require__.d(__webpack_exports__, "a", function() { return compose; });
|
650 | __webpack_require__.d(__webpack_exports__, "m", function() { return toggleRowStatus; });
|
651 | __webpack_require__.d(__webpack_exports__, "n", function() { return walkTreeNode; });
|
652 | var element_ui_src_utils_util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
|
653 | var element_ui_src_utils_util__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(element_ui_src_utils_util__WEBPACK_IMPORTED_MODULE_0__);
|
654 | 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; };
|
655 |
|
656 |
|
657 |
|
658 | var getCell = function getCell(event) {
|
659 | var cell = event.target;
|
660 |
|
661 | while (cell && cell.tagName.toUpperCase() !== 'HTML') {
|
662 | if (cell.tagName.toUpperCase() === 'TD') {
|
663 | return cell;
|
664 | }
|
665 | cell = cell.parentNode;
|
666 | }
|
667 |
|
668 | return null;
|
669 | };
|
670 |
|
671 | var isObject = function isObject(obj) {
|
672 | return obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';
|
673 | };
|
674 |
|
675 | var orderBy = function orderBy(array, sortKey, reverse, sortMethod, sortBy) {
|
676 | if (!sortKey && !sortMethod && (!sortBy || Array.isArray(sortBy) && !sortBy.length)) {
|
677 | return array;
|
678 | }
|
679 | if (typeof reverse === 'string') {
|
680 | reverse = reverse === 'descending' ? -1 : 1;
|
681 | } else {
|
682 | reverse = reverse && reverse < 0 ? -1 : 1;
|
683 | }
|
684 | var getKey = sortMethod ? null : function (value, index) {
|
685 | if (sortBy) {
|
686 | if (!Array.isArray(sortBy)) {
|
687 | sortBy = [sortBy];
|
688 | }
|
689 | return sortBy.map(function (by) {
|
690 | if (typeof by === 'string') {
|
691 | return Object(element_ui_src_utils_util__WEBPACK_IMPORTED_MODULE_0__["getValueByPath"])(value, by);
|
692 | } else {
|
693 | return by(value, index, array);
|
694 | }
|
695 | });
|
696 | }
|
697 | if (sortKey !== '$key') {
|
698 | if (isObject(value) && '$value' in value) value = value.$value;
|
699 | }
|
700 | return [isObject(value) ? Object(element_ui_src_utils_util__WEBPACK_IMPORTED_MODULE_0__["getValueByPath"])(value, sortKey) : value];
|
701 | };
|
702 | var compare = function compare(a, b) {
|
703 | if (sortMethod) {
|
704 | return sortMethod(a.value, b.value);
|
705 | }
|
706 | for (var i = 0, len = a.key.length; i < len; i++) {
|
707 | if (a.key[i] < b.key[i]) {
|
708 | return -1;
|
709 | }
|
710 | if (a.key[i] > b.key[i]) {
|
711 | return 1;
|
712 | }
|
713 | }
|
714 | return 0;
|
715 | };
|
716 | return array.map(function (value, index) {
|
717 | return {
|
718 | value: value,
|
719 | index: index,
|
720 | key: getKey ? getKey(value, index) : null
|
721 | };
|
722 | }).sort(function (a, b) {
|
723 | var order = compare(a, b);
|
724 | if (!order) {
|
725 |
|
726 | order = a.index - b.index;
|
727 | }
|
728 | return order * reverse;
|
729 | }).map(function (item) {
|
730 | return item.value;
|
731 | });
|
732 | };
|
733 |
|
734 | var getColumnById = function getColumnById(table, columnId) {
|
735 | var column = null;
|
736 | table.columns.forEach(function (item) {
|
737 | if (item.id === columnId) {
|
738 | column = item;
|
739 | }
|
740 | });
|
741 | return column;
|
742 | };
|
743 |
|
744 | var getColumnByKey = function getColumnByKey(table, columnKey) {
|
745 | var column = null;
|
746 | for (var i = 0; i < table.columns.length; i++) {
|
747 | var item = table.columns[i];
|
748 | if (item.columnKey === columnKey) {
|
749 | column = item;
|
750 | break;
|
751 | }
|
752 | }
|
753 | return column;
|
754 | };
|
755 |
|
756 | var getColumnByCell = function getColumnByCell(table, cell) {
|
757 | var matches = (cell.className || '').match(/el-table_[^\s]+/gm);
|
758 | if (matches) {
|
759 | return getColumnById(table, matches[0]);
|
760 | }
|
761 | return null;
|
762 | };
|
763 |
|
764 | var getRowIdentity = function getRowIdentity(row, rowKey) {
|
765 | if (!row) throw new Error('row is required when get row identity');
|
766 | if (typeof rowKey === 'string') {
|
767 | if (rowKey.indexOf('.') < 0) {
|
768 | return row[rowKey];
|
769 | }
|
770 | var key = rowKey.split('.');
|
771 | var current = row;
|
772 | for (var i = 0; i < key.length; i++) {
|
773 | current = current[key[i]];
|
774 | }
|
775 | return current;
|
776 | } else if (typeof rowKey === 'function') {
|
777 | return rowKey.call(null, row);
|
778 | }
|
779 | };
|
780 |
|
781 | var getKeysMap = function getKeysMap(array, rowKey) {
|
782 | var arrayMap = {};
|
783 | (array || []).forEach(function (row, index) {
|
784 | arrayMap[getRowIdentity(row, rowKey)] = { row: row, index: index };
|
785 | });
|
786 | return arrayMap;
|
787 | };
|
788 |
|
789 | function hasOwn(obj, key) {
|
790 | return Object.prototype.hasOwnProperty.call(obj, key);
|
791 | }
|
792 |
|
793 | function mergeOptions(defaults, config) {
|
794 | var options = {};
|
795 | var key = void 0;
|
796 | for (key in defaults) {
|
797 | options[key] = defaults[key];
|
798 | }
|
799 | for (key in config) {
|
800 | if (hasOwn(config, key)) {
|
801 | var value = config[key];
|
802 | if (typeof value !== 'undefined') {
|
803 | options[key] = value;
|
804 | }
|
805 | }
|
806 | }
|
807 | return options;
|
808 | }
|
809 |
|
810 | function parseWidth(width) {
|
811 | if (width !== undefined) {
|
812 | width = parseInt(width, 10);
|
813 | if (isNaN(width)) {
|
814 | width = null;
|
815 | }
|
816 | }
|
817 | return width;
|
818 | }
|
819 |
|
820 | function parseMinWidth(minWidth) {
|
821 | if (typeof minWidth !== 'undefined') {
|
822 | minWidth = parseWidth(minWidth);
|
823 | if (isNaN(minWidth)) {
|
824 | minWidth = 80;
|
825 | }
|
826 | }
|
827 | return minWidth;
|
828 | };
|
829 |
|
830 | function parseHeight(height) {
|
831 | if (typeof height === 'number') {
|
832 | return height;
|
833 | }
|
834 | if (typeof height === 'string') {
|
835 | if (/^\d+(?:px)?$/.test(height)) {
|
836 | return parseInt(height, 10);
|
837 | } else {
|
838 | return height;
|
839 | }
|
840 | }
|
841 | return null;
|
842 | }
|
843 |
|
844 |
|
845 | function compose() {
|
846 | for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
|
847 | funcs[_key] = arguments[_key];
|
848 | }
|
849 |
|
850 | if (funcs.length === 0) {
|
851 | return function (arg) {
|
852 | return arg;
|
853 | };
|
854 | }
|
855 | if (funcs.length === 1) {
|
856 | return funcs[0];
|
857 | }
|
858 | return funcs.reduce(function (a, b) {
|
859 | return function () {
|
860 | return a(b.apply(undefined, arguments));
|
861 | };
|
862 | });
|
863 | }
|
864 |
|
865 | function toggleRowStatus(statusArr, row, newVal) {
|
866 | var changed = false;
|
867 | var index = statusArr.indexOf(row);
|
868 | var included = index !== -1;
|
869 |
|
870 | var addRow = function addRow() {
|
871 | statusArr.push(row);
|
872 | changed = true;
|
873 | };
|
874 | var removeRow = function removeRow() {
|
875 | statusArr.splice(index, 1);
|
876 | changed = true;
|
877 | };
|
878 |
|
879 | if (typeof newVal === 'boolean') {
|
880 | if (newVal && !included) {
|
881 | addRow();
|
882 | } else if (!newVal && included) {
|
883 | removeRow();
|
884 | }
|
885 | } else {
|
886 | if (included) {
|
887 | removeRow();
|
888 | } else {
|
889 | addRow();
|
890 | }
|
891 | }
|
892 | return changed;
|
893 | }
|
894 |
|
895 | function walkTreeNode(root, cb) {
|
896 | var childrenKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children';
|
897 | var lazyKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'hasChildren';
|
898 |
|
899 | var isNil = function isNil(array) {
|
900 | return !(Array.isArray(array) && array.length);
|
901 | };
|
902 |
|
903 | function _walker(parent, children, level) {
|
904 | cb(parent, children, level);
|
905 | children.forEach(function (item) {
|
906 | if (item[lazyKey]) {
|
907 | cb(item, null, level + 1);
|
908 | return;
|
909 | }
|
910 | var children = item[childrenKey];
|
911 | if (!isNil(children)) {
|
912 | _walker(item, children, level + 1);
|
913 | }
|
914 | });
|
915 | }
|
916 |
|
917 | root.forEach(function (item) {
|
918 | if (item[lazyKey]) {
|
919 | cb(item, null, 0);
|
920 | return;
|
921 | }
|
922 | var children = item[childrenKey];
|
923 | if (!isNil(children)) {
|
924 | _walker(item, children, 0);
|
925 | }
|
926 | });
|
927 | }
|
928 |
|
929 | })
|
930 |
|
931 | }); |
\ | No newline at end of file |