[build] 7.1.0

dist/vue-class-component.common.js

@@ -1,5 +1,5 @@
 /**
- * vue-class-component v7.0.2
+ * vue-class-component v7.1.0
  * (c) 2015-present Evan You
  * @license MIT
  */

dist/vue-class-component.esm.js

@@ -0,0 +1,272 @@
+/**
+ * vue-class-component v7.1.0
+ * (c) 2015-present Evan You
+ * @license MIT
+ */
+import Vue from 'vue';
+
+// The rational behind the verbose Reflect-feature check below is the fact that there are polyfills
+// which add an implementation for Reflect.defineMetadata but not for Reflect.getOwnMetadataKeys.
+// Without this check consumers will encounter hard to track down runtime errors.
+var reflectionIsSupported = typeof Reflect !== 'undefined' && Reflect.defineMetadata && Reflect.getOwnMetadataKeys;
+function copyReflectionMetadata(to, from) {
+ forwardMetadata(to, from);
+ Object.getOwnPropertyNames(from.prototype).forEach(function (key) {
+ forwardMetadata(to.prototype, from.prototype, key);
+ });
+ Object.getOwnPropertyNames(from).forEach(function (key) {
+ forwardMetadata(to, from, key);
+ });
+}
+function forwardMetadata(to, from, propertyKey) {
+ var metaKeys = propertyKey
+ ? Reflect.getOwnMetadataKeys(from, propertyKey)
+ : Reflect.getOwnMetadataKeys(from);
+ metaKeys.forEach(function (metaKey) {
+ var metadata = propertyKey
+ ? Reflect.getOwnMetadata(metaKey, from, propertyKey)
+ : Reflect.getOwnMetadata(metaKey, from);
+ if (propertyKey) {
+ Reflect.defineMetadata(metaKey, metadata, to, propertyKey);
+ }
+ else {
+ Reflect.defineMetadata(metaKey, metadata, to);
+ }
+ });
+}
+
+var fakeArray = { __proto__: [] };
+var hasProto = fakeArray instanceof Array;
+function createDecorator(factory) {
+ return function (target, key, index) {
+ var Ctor = typeof target === 'function'
+ ? target
+ : target.constructor;
+ if (!Ctor.__decorators__) {
+ Ctor.__decorators__ = [];
+ }
+ if (typeof index !== 'number') {
+ index = undefined;
+ }
+ Ctor.__decorators__.push(function (options) { return factory(options, key, index); });
+ };
+}
+function mixins() {
+ var Ctors = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ Ctors[_i] = arguments[_i];
+ }
+ return Vue.extend({ mixins: Ctors });
+}
+function isPrimitive(value) {
+ var type = typeof value;
+ return value == null || (type !== 'object' && type !== 'function');
+}
+function warn(message) {
+ if (typeof console !== 'undefined') {
+ console.warn('[vue-class-component] ' + message);
+ }
+}
+
+function collectDataFromConstructor(vm, Component) {
+ // override _init to prevent to init as Vue instance
+ var originalInit = Component.prototype._init;
+ Component.prototype._init = function () {
+ var _this = this;
+ // proxy to actual vm
+ var keys = Object.getOwnPropertyNames(vm);
+ // 2.2.0 compat (props are no longer exposed as self properties)
+ if (vm.$options.props) {
+ for (var key in vm.$options.props) {
+ if (!vm.hasOwnProperty(key)) {
+ keys.push(key);
+ }
+ }
+ }
+ keys.forEach(function (key) {
+ if (key.charAt(0) !== '_') {
+ Object.defineProperty(_this, key, {
+ get: function () { return vm[key]; },
+ set: function (value) { vm[key] = value; },
+ configurable: true
+ });
+ }
+ });
+ };
+ // should be acquired class property values
+ var data = new Component();
+ // restore original _init to avoid memory leak (#209)
+ Component.prototype._init = originalInit;
+ // create plain data object
+ var plainData = {};
+ Object.keys(data).forEach(function (key) {
+ if (data[key] !== undefined) {
+ plainData[key] = data[key];
+ }
+ });
+ if (process.env.NODE_ENV !== 'production') {
+ if (!(Component.prototype instanceof Vue) && Object.keys(plainData).length > 0) {
+ warn('Component class must inherit Vue or its descendant class ' +
+ 'when class property is used.');
+ }
+ }
+ return plainData;
+}
+
+var $internalHooks = [
+ 'data',
+ 'beforeCreate',
+ 'created',
+ 'beforeMount',
+ 'mounted',
+ 'beforeDestroy',
+ 'destroyed',
+ 'beforeUpdate',
+ 'updated',
+ 'activated',
+ 'deactivated',
+ 'render',
+ 'errorCaptured',
+ 'serverPrefetch' // 2.6
+];
+function componentFactory(Component, options) {
+ if (options === void 0) { options = {}; }
+ options.name = options.name || Component._componentTag || Component.name;
+ // prototype props.
+ var proto = Component.prototype;
+ Object.getOwnPropertyNames(proto).forEach(function (key) {
+ if (key === 'constructor') {
+ return;
+ }
+ // hooks
+ if ($internalHooks.indexOf(key) > -1) {
+ options[key] = proto[key];
+ return;
+ }
+ var descriptor = Object.getOwnPropertyDescriptor(proto, key);
+ if (descriptor.value !== void 0) {
+ // methods
+ if (typeof descriptor.value === 'function') {
+ (options.methods || (options.methods = {}))[key] = descriptor.value;
+ }
+ else {
+ // typescript decorated data
+ (options.mixins || (options.mixins = [])).push({
+ data: function () {
+ var _a;
+ return _a = {}, _a[key] = descriptor.value, _a;
+ }
+ });
+ }
+ }
+ else if (descriptor.get || descriptor.set) {
+ // computed properties
+ (options.computed || (options.computed = {}))[key] = {
+ get: descriptor.get,
+ set: descriptor.set
+ };
+ }
+ });
+ (options.mixins || (options.mixins = [])).push({
+ data: function () {
+ return collectDataFromConstructor(this, Component);
+ }
+ });
+ // decorate options
+ var decorators = Component.__decorators__;
+ if (decorators) {
+ decorators.forEach(function (fn) { return fn(options); });
+ delete Component.__decorators__;
+ }
+ // find super
+ var superProto = Object.getPrototypeOf(Component.prototype);
+ var Super = superProto instanceof Vue
+ ? superProto.constructor
+ : Vue;
+ var Extended = Super.extend(options);
+ forwardStaticMembers(Extended, Component, Super);
+ if (reflectionIsSupported) {
+ copyReflectionMetadata(Extended, Component);
+ }
+ return Extended;
+}
+var reservedPropertyNames = [
+ // Unique id
+ 'cid',
+ // Super Vue constructor
+ 'super',
+ // Component options that will be used by the component
+ 'options',
+ 'superOptions',
+ 'extendOptions',
+ 'sealedOptions',
+ // Private assets
+ 'component',
+ 'directive',
+ 'filter'
+];
+var shouldIgnore = {
+ prototype: true,
+ arguments: true,
+ callee: true,
+ caller: true
+};
+function forwardStaticMembers(Extended, Original, Super) {
+ // We have to use getOwnPropertyNames since Babel registers methods as non-enumerable
+ Object.getOwnPropertyNames(Original).forEach(function (key) {
+ // Skip the properties that should not be overwritten
+ if (shouldIgnore[key]) {
+ return;
+ }
+ // Some browsers does not allow reconfigure built-in properties
+ var extendedDescriptor = Object.getOwnPropertyDescriptor(Extended, key);
+ if (extendedDescriptor && !extendedDescriptor.configurable) {
+ return;
+ }
+ var descriptor = Object.getOwnPropertyDescriptor(Original, key);
+ // If the user agent does not support `__proto__` or its family (IE <= 10),
+ // the sub class properties may be inherited properties from the super class in TypeScript.
+ // We need to exclude such properties to prevent to overwrite
+ // the component options object which stored on the extended constructor (See #192).
+ // If the value is a referenced value (object or function),
+ // we can check equality of them and exclude it if they have the same reference.
+ // If it is a primitive value, it will be forwarded for safety.
+ if (!hasProto) {
+ // Only `cid` is explicitly exluded from property forwarding
+ // because we cannot detect whether it is a inherited property or not
+ // on the no `__proto__` environment even though the property is reserved.
+ if (key === 'cid') {
+ return;
+ }
+ var superDescriptor = Object.getOwnPropertyDescriptor(Super, key);
+ if (!isPrimitive(descriptor.value) &&
+ superDescriptor &&
+ superDescriptor.value === descriptor.value) {
+ return;
+ }
+ }
+ // Warn if the users manually declare reserved properties
+ if (process.env.NODE_ENV !== 'production' &&
+ reservedPropertyNames.indexOf(key) >= 0) {
+ warn("Static property name '" + key + "' declared on class '" + Original.name + "' " +
+ 'conflicts with reserved property name of Vue internal. ' +
+ 'It may cause unexpected behavior of the component. Consider renaming the property.');
+ }
+ Object.defineProperty(Extended, key, descriptor);
+ });
+}
+
+function Component(options) {
+ if (typeof options === 'function') {
+ return componentFactory(options);
+ }
+ return function (Component) {
+ return componentFactory(Component, options);
+ };
+}
+Component.registerHooks = function registerHooks(keys) {
+ $internalHooks.push.apply($internalHooks, keys);
+};
+
+export default Component;
+export { createDecorator, mixins };

dist/vue-class-component.js

@@ -1,5 +1,5 @@
 /**
- * vue-class-component v7.0.2
+ * vue-class-component v7.1.0
  * (c) 2015-present Evan You
  * @license MIT
  */