cy-element-ui 1.0.0 → 1.0.2

package/lib/message.js

@@ -0,0 +1,548 @@
+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 = 81);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (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
+  }
+}
+
+
+/***/ }),
+
+/***/ 13:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/popup");
+
+/***/ }),
+
+/***/ 18:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/types");
+
+/***/ }),
+
+/***/ 23:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/vdom");
+
+/***/ }),
+
+/***/ 7:
+/***/ (function(module, exports) {
+
+module.exports = require("vue");
+
+/***/ }),
+
+/***/ 81:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXTERNAL MODULE: external "vue"
+var external_vue_ = __webpack_require__(7);
+var external_vue_default = /*#__PURE__*/__webpack_require__.n(external_vue_);
+
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/message/src/main.vue?vue&type=template&id=42076ee3
+var render = function () {
+  var _vm = this
+  var _h = _vm.$createElement
+  var _c = _vm._self._c || _h
+  return _c(
+    "transition",
+    {
+      attrs: { name: "el-message-fade" },
+      on: { "after-leave": _vm.handleAfterLeave },
+    },
+    [
+      _c(
+        "div",
+        {
+          directives: [
+            {
+              name: "show",
+              rawName: "v-show",
+              value: _vm.visible,
+              expression: "visible",
+            },
+          ],
+          class: [
+            "el-message",
+            _vm.type && !_vm.iconClass ? "el-message--" + _vm.type : "",
+            _vm.center ? "is-center" : "",
+            _vm.showClose ? "is-closable" : "",
+            _vm.customClass,
+          ],
+          style: _vm.positionStyle,
+          attrs: { role: "alert" },
+          on: { mouseenter: _vm.clearTimer, mouseleave: _vm.startTimer },
+        },
+        [
+          _vm.iconClass
+            ? _c("i", { class: _vm.iconClass })
+            : _c("i", { class: _vm.typeClass }),
+          _vm._t("default", [
+            !_vm.dangerouslyUseHTMLString
+              ? _c("p", { staticClass: "el-message__content" }, [
+                  _vm._v(_vm._s(_vm.message)),
+                ])
+              : _c("p", {
+                  staticClass: "el-message__content",
+                  domProps: { innerHTML: _vm._s(_vm.message) },
+                }),
+          ]),
+          _vm.showClose
+            ? _c("i", {
+                staticClass: "el-message__closeBtn el-icon-close",
+                on: { click: _vm.close },
+              })
+            : _vm._e(),
+        ],
+        2
+      ),
+    ]
+  )
+}
+var staticRenderFns = []
+render._withStripped = true
+
+
+// CONCATENATED MODULE: ./packages/message/src/main.vue?vue&type=template&id=42076ee3
+
+// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/message/src/main.vue?vue&type=script&lang=js
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+var typeMap = {
+	success: 'success',
+	info: 'info',
+	warning: 'warning',
+	error: 'error'
+};
+
+/* harmony default export */ var mainvue_type_script_lang_js = ({
+	data: function data() {
+		return {
+			visible: false,
+			message: '',
+			duration: 3000,
+			type: 'info',
+			iconClass: '',
+			customClass: '',
+			onClose: null,
+			showClose: false,
+			closed: false,
+			verticalOffset: 20,
+			timer: null,
+			dangerouslyUseHTMLString: false,
+			center: false
+		};
+	},
+
+
+	computed: {
+		typeClass: function typeClass() {
+			return this.type && !this.iconClass ? 'el-message__icon el-icon-' + typeMap[this.type] : '';
+		},
+		positionStyle: function positionStyle() {
+			return {
+				'top': this.verticalOffset + 'px'
+			};
+		}
+	},
+
+	watch: {
+		closed: function closed(newVal) {
+			if (newVal) {
+				this.visible = false;
+			}
+		}
+	},
+
+	methods: {
+		handleAfterLeave: function handleAfterLeave() {
+			this.$destroy(true);
+			this.$el.parentNode.removeChild(this.$el);
+		},
+		close: function close() {
+			this.closed = true;
+			if (typeof this.onClose === 'function') {
+				this.onClose(this);
+			}
+		},
+		clearTimer: function clearTimer() {
+			clearTimeout(this.timer);
+		},
+		startTimer: function startTimer() {
+			var _this = this;
+
+			if (this.duration > 0) {
+				this.timer = setTimeout(function () {
+					if (!_this.closed) {
+						_this.close();
+					}
+				}, this.duration);
+			}
+		},
+		keydown: function keydown(e) {
+			if (e.keyCode === 27) {
+				// esc关闭消息
+				if (!this.closed) {
+					this.close();
+				}
+			}
+		}
+	},
+	mounted: function mounted() {
+		this.startTimer();
+		document.addEventListener('keydown', this.keydown);
+	},
+	beforeDestroy: function beforeDestroy() {
+		document.removeEventListener('keydown', this.keydown);
+	}
+});
+// CONCATENATED MODULE: ./packages/message/src/main.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_mainvue_type_script_lang_js = (mainvue_type_script_lang_js); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(0);
+
+// CONCATENATED MODULE: ./packages/message/src/main.vue
+
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  src_mainvue_type_script_lang_js,
+  render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var main = (component.exports);
+// EXTERNAL MODULE: external "element-ui/lib/utils/popup"
+var popup_ = __webpack_require__(13);
+
+// EXTERNAL MODULE: external "element-ui/lib/utils/vdom"
+var vdom_ = __webpack_require__(23);
+
+// EXTERNAL MODULE: external "element-ui/lib/utils/types"
+var types_ = __webpack_require__(18);
+
+// CONCATENATED MODULE: ./packages/message/src/main.js
+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; };
+
+
+
+
+
+
+var MessageConstructor = external_vue_default.a.extend(main);
+
+var instance = void 0;
+var instances = [];
+var seed = 1;
+
+var main_Message = function Message(options) {
+	if (external_vue_default.a.prototype.$isServer) return;
+	options = options || {};
+	if (typeof options === 'string') {
+		options = {
+			message: options
+		};
+	}
+	var userOnClose = options.onClose;
+	var id = 'message_' + seed++;
+
+	options.onClose = function () {
+		Message.close(id, userOnClose);
+	};
+	instance = new MessageConstructor({
+		data: options
+	});
+	instance.id = id;
+	if (Object(vdom_["isVNode"])(instance.message)) {
+		instance.$slots.default = [instance.message];
+		instance.message = null;
+	}
+	instance.$mount();
+	document.body.appendChild(instance.$el);
+	var verticalOffset = options.offset || 20;
+	instances.forEach(function (item) {
+		verticalOffset += item.$el.offsetHeight + 16;
+	});
+	instance.verticalOffset = verticalOffset;
+	instance.visible = true;
+	instance.$el.style.zIndex = popup_["PopupManager"].nextZIndex();
+	instances.push(instance);
+	return instance;
+};
+
+['success', 'warning', 'info', 'error'].forEach(function (type) {
+	main_Message[type] = function (options) {
+		if (Object(types_["isObject"])(options) && !Object(vdom_["isVNode"])(options)) {
+			return main_Message(_extends({}, options, {
+				type: type
+			}));
+		}
+		return main_Message({
+			type: type,
+			message: options
+		});
+	};
+});
+
+main_Message.close = function (id, userOnClose) {
+	var len = instances.length;
+	var index = -1;
+	var removedHeight = void 0;
+	for (var i = 0; i < len; i++) {
+		if (id === instances[i].id) {
+			removedHeight = instances[i].$el.offsetHeight;
+			index = i;
+			if (typeof userOnClose === 'function') {
+				userOnClose(instances[i]);
+			}
+			instances.splice(i, 1);
+			break;
+		}
+	}
+	if (len <= 1 || index === -1 || index > instances.length - 1) return;
+	for (var _i = index; _i < len - 1; _i++) {
+		var dom = instances[_i].$el;
+		dom.style['top'] = parseInt(dom.style['top'], 10) - removedHeight - 16 + 'px';
+	}
+};
+
+main_Message.closeAll = function () {
+	for (var i = instances.length - 1; i >= 0; i--) {
+		instances[i].close();
+	}
+};
+
+/* harmony default export */ var src_main = (main_Message);
+// CONCATENATED MODULE: ./packages/message/index.js
+
+/* harmony default export */ var message = __webpack_exports__["default"] = (src_main);
+
+/***/ })
+
+/******/ });

package/lib/mixins/emitter.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+function _broadcast(componentName, eventName, params) {
+	this.$children.forEach(function (child) {
+		var name = child.$options.componentName;
+
+		if (name === componentName) {
+			child.$emit.apply(child, [eventName].concat(params));
+		} else {
+			_broadcast.apply(child, [componentName, eventName].concat([params]));
+		}
+	});
+}
+exports.default = {
+	methods: {
+		dispatch: function dispatch(componentName, eventName, params) {
+			var parent = this.$parent || this.$root;
+			var name = parent.$options.componentName;
+
+			while (parent && (!name || name !== componentName)) {
+				parent = parent.$parent;
+
+				if (parent) {
+					name = parent.$options.componentName;
+				}
+			}
+			if (parent) {
+				parent.$emit.apply(parent, [eventName].concat(params));
+			}
+		},
+		broadcast: function broadcast(componentName, eventName, params) {
+			_broadcast.call(this, componentName, eventName, params);
+		}
+	}
+};

package/lib/mixins/focus.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+
+exports.default = function (ref) {
+	return {
+		methods: {
+			focus: function focus() {
+				this.$refs[ref].focus();
+			}
+		}
+	};
+};
+
+;

package/lib/mixins/locale.js

@@ -0,0 +1,17 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _locale = require('element-ui/lib/locale');
+
+exports.default = {
+	methods: {
+		t: function t() {
+			for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+				args[_key] = arguments[_key];
+			}
+
+			return _locale.t.apply(this, args);
+		}
+	}
+};

package/lib/mixins/migrating.js

@@ -0,0 +1,69 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _util = require('element-ui/lib/utils/util');
+
+/**
+ * Show migrating guide in browser console.
+ *
+ * Usage:
+ * import Migrating from 'element-ui/src/mixins/migrating';
+ *
+ * mixins: [Migrating]
+ *
+ * add getMigratingConfig method for your component.
+ *  getMigratingConfig() {
+ *    return {
+ *      props: {
+ *        'allow-no-selection': 'allow-no-selection is removed.',
+ *        'selection-mode': 'selection-mode is removed.'
+ *      },
+ *      events: {
+ *        selectionchange: 'selectionchange is renamed to selection-change.'
+ *      }
+ *    };
+ *  },
+ */
+exports.default = {
+	mounted: function mounted() {
+		if (process.env.NODE_ENV === 'production') return;
+		if (!this.$vnode) return;
+
+		var _getMigratingConfig = this.getMigratingConfig(),
+		    _getMigratingConfig$p = _getMigratingConfig.props,
+		    props = _getMigratingConfig$p === undefined ? {} : _getMigratingConfig$p,
+		    _getMigratingConfig$e = _getMigratingConfig.events,
+		    events = _getMigratingConfig$e === undefined ? {} : _getMigratingConfig$e;
+
+		var _$vnode = this.$vnode,
+		    data = _$vnode.data,
+		    componentOptions = _$vnode.componentOptions;
+
+		var definedProps = data.attrs || {};
+		var definedEvents = componentOptions.listeners || {};
+
+		for (var propName in definedProps) {
+			propName = (0, _util.kebabCase)(propName); // compatible with camel case
+			if (props[propName]) {
+				console.warn('[Element Migrating][' + this.$options.name + '][Attribute]: ' + props[propName]);
+			}
+		}
+
+		for (var eventName in definedEvents) {
+			eventName = (0, _util.kebabCase)(eventName); // compatible with camel case
+			if (events[eventName]) {
+				console.warn('[Element Migrating][' + this.$options.name + '][Event]: ' + events[eventName]);
+			}
+		}
+	},
+
+	methods: {
+		getMigratingConfig: function getMigratingConfig() {
+			return {
+				props: {},
+				events: {}
+			};
+		}
+	}
+};