268 lines
8.5 KiB
JavaScript
268 lines
8.5 KiB
JavaScript
![]() |
/* eslint-disable */
|
||
|
/*eslint no-unused-vars: "off" */
|
||
|
/**
|
||
|
* vue-class-component v7.2.5
|
||
|
* (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.
|
||
|
function reflectionIsSupported() {
|
||
|
return typeof Reflect !== 'undefined' && Reflect.defineMetadata && Reflect.getOwnMetadataKeys;
|
||
|
}
|
||
|
function copyReflectionMetadata(to, from) {
|
||
|
forwardMetadata(to, from);
|
||
|
Object.getOwnPropertyNames(from.prototype).forEach(key => {
|
||
|
forwardMetadata(to.prototype, from.prototype, key);
|
||
|
});
|
||
|
Object.getOwnPropertyNames(from).forEach(key => {
|
||
|
forwardMetadata(to, from, key);
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function forwardMetadata(to, from, propertyKey) {
|
||
|
var metaKeys = propertyKey ? Reflect.getOwnMetadataKeys(from, propertyKey) : Reflect.getOwnMetadataKeys(from);
|
||
|
metaKeys.forEach(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 (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(options => factory(options, key, index));
|
||
|
};
|
||
|
}
|
||
|
function mixins() {
|
||
|
for (var _len = arguments.length, Ctors = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
|
Ctors[_key] = arguments[_key];
|
||
|
}
|
||
|
|
||
|
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 () {
|
||
|
// 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(key => {
|
||
|
Object.defineProperty(this, key, {
|
||
|
get: () => vm[key],
|
||
|
set: 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(key => {
|
||
|
if (data[key] !== undefined) {
|
||
|
plainData[key] = data[key];
|
||
|
}
|
||
|
});
|
||
|
|
||
|
{
|
||
|
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) {
|
||
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
|
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() {
|
||
|
return {
|
||
|
[key]: descriptor.value
|
||
|
};
|
||
|
}
|
||
|
|
||
|
});
|
||
|
}
|
||
|
} 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() {
|
||
|
return collectDataFromConstructor(this, Component);
|
||
|
}
|
||
|
|
||
|
}); // decorate options
|
||
|
|
||
|
var decorators = Component.__decorators__;
|
||
|
|
||
|
if (decorators) {
|
||
|
decorators.forEach(fn => 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(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 ( reservedPropertyNames.indexOf(key) >= 0) {
|
||
|
warn("Static property name '".concat(key, "' declared on class '").concat(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(...keys);
|
||
|
};
|
||
|
|
||
|
export { Component, createDecorator, mixins };
|
||
|
|