vue-class-component.js

/**
  * vue-class-component v7.1.0
  * (c) 2015-present Evan You
  * @license MIT
  */
(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
    typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) :
    (factory((global.VueClassComponent = {}),global.Vue));
}(this, (function (exports,Vue) { 'use strict';

    Vue = Vue && Vue.hasOwnProperty('default') ? Vue['default'] : 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 (!(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 (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);
    };

    exports.default = Component;
    exports.createDecorator = createDecorator;
    exports.mixins = mixins;

    Object.defineProperty(exports, '__esModule', { value: true });

})));